fastly_nsq 1.17.0 → 1.17.1

data/spec/messenger_spec.rb

@@ -1,23 +1,22 @@
-
 # frozen_string_literal: true
 
-require 'spec_helper'
-require 'json'
+require "spec_helper"
+require "json"
 
 RSpec.describe FastlyNsq::Messenger do
-  let(:message)  { { sample: 'sample', message: 'message' } }
-  let(:message2) { { sample: 'elpmas', message: 'egassem' } }
-  let(:producer) { double 'FastlyNsq::Producer', write: nil, terminate: :terminated }
-  let(:origin)   { 'originating_service' }
-  let(:sent_at)  { Time.now.iso8601(5) }
+  let(:message) { {sample: "sample", message: "message"} }
+  let(:message2) { {sample: "elpmas", message: "egassem"} }
+  let(:producer) { double "FastlyNsq::Producer", write: nil, terminate: :terminated }
+  let(:origin) { "originating_service" }
+  let(:sent_at) { Time.now.iso8601(5) }
 
   let(:expected_attributes) do
     {
       data: message,
       meta: {
-        originating_service: 'originating_service',
-        sent_at: sent_at,
-      },
+        originating_service: "originating_service",
+        sent_at: sent_at
+      }
     }
   end
 
@@ -27,100 +26,100 @@ RSpec.describe FastlyNsq::Messenger do
     FastlyNsq::Messenger.instance_variable_set(:@producers, nil)
   end
 
-  describe '#deliver' do
+  describe "#deliver" do
     before { Timecop.freeze(sent_at) }
 
-    it 'writes a single message on a producer' do
-      subject.producers['topic'] = producer
+    it "writes a single message on a producer" do
+      subject.producers["topic"] = producer
 
-      subject.deliver message: message, topic: 'topic', originating_service: origin
+      subject.deliver message: message, topic: "topic", originating_service: origin
 
       expect(producer).to have_received(:write).with(expected_attributes.to_json)
     end
 
-    it 'uses a Unknown for the default originating_service' do
-      subject.producers['topic'] = producer
-      expected_attributes[:meta][:originating_service] = 'Unknown'
+    it "uses a Unknown for the default originating_service" do
+      subject.producers["topic"] = producer
+      expected_attributes[:meta][:originating_service] = "Unknown"
 
-      subject.deliver message: message, topic: 'topic'
+      subject.deliver message: message, topic: "topic"
 
       expect(producer).to have_received(:write).with(expected_attributes.to_json)
     end
 
-    it 'allows setting arbitrary metadata' do
-      meta = { test: 'test' }
+    it "allows setting arbitrary metadata" do
+      meta = {test: "test"}
 
-      expected_attributes = { data: message, meta: meta.merge(originating_service: origin, sent_at: sent_at) }
+      expected_attributes = {data: message, meta: meta.merge(originating_service: origin, sent_at: sent_at)}
 
-      subject.producers['topic'] = producer
+      subject.producers["topic"] = producer
 
-      subject.deliver message: message, topic: 'topic', meta: meta, originating_service: origin
+      subject.deliver message: message, topic: "topic", meta: meta, originating_service: origin
 
       expect(producer).to have_received(:write).with(expected_attributes.to_json)
     end
 
-    it 'prevents originating_service from being overwritten by meta' do
-      meta = { test: 'test' }
+    it "prevents originating_service from being overwritten by meta" do
+      meta = {test: "test"}
 
-      expected_attributes = { data: message, meta: meta.merge(originating_service: origin, sent_at: sent_at) }
+      expected_attributes = {data: message, meta: meta.merge(originating_service: origin, sent_at: sent_at)}
 
-      meta[:originating_service] = 'other_service'
+      meta[:originating_service] = "other_service"
 
-      subject.producers['topic'] = producer
+      subject.producers["topic"] = producer
 
-      subject.deliver message: message, topic: 'topic', meta: meta, originating_service: origin
+      subject.deliver message: message, topic: "topic", meta: meta, originating_service: origin
 
       expect(producer).to have_received(:write).with(expected_attributes.to_json)
     end
 
-    it 'can set the sent_at in the metadata' do
-      sent_at = Time.parse('2020-06-08 23:42:42')
+    it "can set the sent_at in the metadata" do
+      sent_at = Time.parse("2020-06-08 23:42:42")
       meta = {}
 
-      expected_attributes = { data: message, meta: meta.merge(originating_service: origin, sent_at: sent_at.iso8601(5)) }
+      expected_attributes = {data: message, meta: meta.merge(originating_service: origin, sent_at: sent_at.iso8601(5))}
 
-      subject.producers['topic'] = producer
+      subject.producers["topic"] = producer
 
-      subject.deliver message: message, topic: 'topic', sent_at: sent_at, meta: meta, originating_service: origin
+      subject.deliver message: message, topic: "topic", sent_at: sent_at, meta: meta, originating_service: origin
 
       expect(producer).to have_received(:write).with(expected_attributes.to_json)
     end
   end
 
-  describe '#deliver_multi' do
+  describe "#deliver_multi" do
     let(:expected_attributes_multi) do
       [
         expected_attributes.to_json,
         {
           data: message2,
           meta: {
-            originating_service: 'originating_service',
-            sent_at: sent_at,
-          },
-        }.to_json,
+            originating_service: "originating_service",
+            sent_at: sent_at
+          }
+        }.to_json
       ]
     end
     before { Timecop.freeze(sent_at) }
 
-    it 'writes an array of messages on a producer' do
-      subject.producers['topic'] = producer
+    it "writes an array of messages on a producer" do
+      subject.producers["topic"] = producer
 
-      subject.deliver_multi messages: [message, message2], topic: 'topic', originating_service: origin
+      subject.deliver_multi messages: [message, message2], topic: "topic", originating_service: origin
 
       expect(producer).to have_received(:write).with(expected_attributes_multi)
     end
   end
 
-  describe '#originating_service=' do
+  describe "#originating_service=" do
     before { Timecop.freeze(sent_at) }
 
     it "set's the default originating service" do
-      subject.producers['nanotopic'] = producer
-      service = 'nano service'
+      subject.producers["nanotopic"] = producer
+      service = "nano service"
       subject.originating_service = service
       expected_attributes[:meta][:originating_service] = service
 
-      subject.deliver message: message, topic: 'nanotopic'
+      subject.deliver message: message, topic: "nanotopic"
 
       expect(producer).to have_received(:write).with(expected_attributes.to_json)
 
@@ -129,42 +128,42 @@ RSpec.describe FastlyNsq::Messenger do
     end
   end
 
-  describe '#producer_for' do
-    it 'returns an FastlyNsq::Producer for the given topic' do
-      my_producer = subject.producer_for(topic: 'my_topic')
+  describe "#producer_for" do
+    it "returns an FastlyNsq::Producer for the given topic" do
+      my_producer = subject.producer_for(topic: "my_topic")
       expect(my_producer).to be_a(FastlyNsq::Producer)
     end
 
-    it 'persists producers' do
-      subject.producers['topic'] = producer
+    it "persists producers" do
+      subject.producers["topic"] = producer
 
-      my_producer = subject.producer_for(topic: 'topic')
+      my_producer = subject.producer_for(topic: "topic")
 
       expect(my_producer).to eq(producer)
     end
   end
 
-  describe '#terminate_producer' do
+  describe "#terminate_producer" do
     before do
-      subject.producers['topic'] = producer
-      subject.terminate_producer(topic: 'topic')
+      subject.producers["topic"] = producer
+      subject.terminate_producer(topic: "topic")
     end
 
-    it 'terminates a producer' do
+    it "terminates a producer" do
       expect(producer).to have_received(:terminate)
     end
 
-    it 'removes the producer from the persisted producers' do
-      expect(subject.producers.key?('topic')).to be(false)
+    it "removes the producer from the persisted producers" do
+      expect(subject.producers.key?("topic")).to be(false)
     end
   end
 
-  describe '#terminate_all_producers' do
-    let(:producer_2) { double 'FastlyNsq::Producer', write: nil, terminate: :terminated }
+  describe "#terminate_all_producers" do
+    let(:producer_2) { double "FastlyNsq::Producer", write: nil, terminate: :terminated }
 
-    it 'terminates all the producers and resets the hash or producers' do
-      subject.producers['topic'] = producer
-      subject.producers['topic_2'] = producer_2
+    it "terminates all the producers and resets the hash or producers" do
+      subject.producers["topic"] = producer
+      subject.producers["topic_2"] = producer_2
 
       subject.terminate_all_producers
 

data/spec/new_relic.rb

@@ -1,29 +1,29 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe FastlyNsq::NewRelic do
-  let(:agent) { double 'NewRelic::Agent', notice_error: true }
+  let(:agent) { double "NewRelic::Agent", notice_error: true }
   let(:tracer) { FastlyNsq::NewRelic.new(agent) }
 
-  describe '#enabled?' do
-    it 'returns false unless NewRelic is loaded' do
-      allow(Object).to receive(:const_defined?).with('NewRelic').and_return(false)
+  describe "#enabled?" do
+    it "returns false unless NewRelic is loaded" do
+      allow(Object).to receive(:const_defined?).with("NewRelic").and_return(false)
       expect(tracer.enabled?).to be false
     end
 
-    it 'returns true id NewRelic is loaded' do
+    it "returns true id NewRelic is loaded" do
       expect(tracer.enabled?).to be true
     end
   end
 
-  context 'enabled' do
+  context "enabled" do
     before do
-      allow(Object).to receive(:const_defined?).with('NewRelic').and_return(true)
+      allow(Object).to receive(:const_defined?).with("NewRelic").and_return(true)
     end
 
-    describe '#notice_error' do
-      it 'call agent.notice_error' do
+    describe "#notice_error" do
+      it "call agent.notice_error" do
         ex = Exception.new
 
         tracer.notice_error(ex)
@@ -31,34 +31,34 @@ RSpec.describe FastlyNsq::NewRelic do
       end
     end
 
-    describe '#trace_with_newrelic' do
-      it 'calls perform_action_with_newrelic_trace and yields' do
+    describe "#trace_with_newrelic" do
+      it "calls perform_action_with_newrelic_trace and yields" do
         allow(tracer).to receive(:perform_action_with_newrelic_trace).and_yield
 
         expect { |b| tracer.trace_with_newrelic({}, &b) }.to yield_control
         expect(tracer).to have_received(:perform_action_with_newrelic_trace)
       end
 
-      it 'calls perform_action_with_newrelic_trace with trace_args' do
-        params = { id: 1, vp: 'joe biden' }
+      it "calls perform_action_with_newrelic_trace with trace_args" do
+        params = {id: 1, vp: "joe biden"}
 
         expected = {
-          name: 'call',
+          name: "call",
           category: FastlyNsq::NewRelic::CATEGORY,
           params: params,
-          class_name: 'SomeClass',
+          class_name: "SomeClass"
         }
 
         allow(tracer).to receive(:perform_action_with_newrelic_trace).and_yield
-        expect { |b| tracer.trace_with_newrelic(params: params, class_name: 'SomeClass', &b) }.to yield_control
+        expect { |b| tracer.trace_with_newrelic(params: params, class_name: "SomeClass", &b) }.to yield_control
 
         expect(tracer).to have_received(:perform_action_with_newrelic_trace).with(expected)
       end
 
-      it 'always sends the default trace args' do
+      it "always sends the default trace args" do
         expected = {
-          name: 'call',
-          category: FastlyNsq::NewRelic::CATEGORY,
+          name: "call",
+          category: FastlyNsq::NewRelic::CATEGORY
         }
         allow(tracer).to receive(:perform_action_with_newrelic_trace).and_yield
 
@@ -69,19 +69,19 @@ RSpec.describe FastlyNsq::NewRelic do
     end
   end
 
-  context 'disabled' do
+  context "disabled" do
     before do
-      allow(Object).to receive(:const_defined?).with('NewRelic').and_return(false)
+      allow(Object).to receive(:const_defined?).with("NewRelic").and_return(false)
     end
 
-    describe '#notice_error' do
-      it 'returns nil' do
-        expect(tracer.notice_error('ex')).to be nil
+    describe "#notice_error" do
+      it "returns nil" do
+        expect(tracer.notice_error("ex")).to be nil
       end
     end
 
-    describe '#trace_with_newrelic' do
-      it 'yields' do
+    describe "#trace_with_newrelic" do
+      it "yields" do
         allow(tracer).to receive(:perform_action_with_newrelic_trace)
 
         expect { |b| tracer.trace_with_newrelic({}, &b) }.to yield_control

data/spec/priority_thread_pool_spec.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe FastlyNsq::PriorityThreadPool do
   let!(:pool) { described_class.new(max_threads: 1) }
 
   after { pool.shutdown || pool.wait_for_termination }
 
-  it 'executes work based on supplied priority' do
+  it "executes work based on supplied priority" do
     actual = []
     count = 10
     count.times { |i| pool.post(i) { actual << i } }

data/spec/producer_spec.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe FastlyNsq::Producer do
-  let!(:topic) { 'fnsq' }
+  let!(:topic) { "fnsq" }
   subject { FastlyNsq::Producer.new(topic: topic) }
 
   before { reset_topic(topic) }
@@ -12,86 +12,86 @@ RSpec.describe FastlyNsq::Producer do
 
   it { should be_connected }
 
-  it 'writes a message' do
-    subject.write 'foo'
+  it "writes a message" do
+    subject.write "foo"
     expect { message_count(topic) }.to eventually(eq(1)).within(5)
   end
 
-  it 'writes multiple messages' do
+  it "writes multiple messages" do
     subject.write %w[foo bar]
     expect { message_count(topic) }.to eventually(eq(2)).within(5)
   end
 
-  it 'should terminate' do
+  it "should terminate" do
     expect { subject.terminate }.to change(subject, :connected?).to(false)
     expect(subject.connection).to eq(nil)
   end
 
-  it 'does not write after termination' do
+  it "does not write after termination" do
     subject.terminate
-    expect { subject.write 'foo' }.to raise_error(FastlyNsq::NotConnectedError)
+    expect { subject.write "foo" }.to raise_error(FastlyNsq::NotConnectedError)
   end
 
-  it 'can connect after termination' do
+  it "can connect after termination" do
     subject.terminate
     expect { subject.connect }.to change(subject, :connected?).to(true)
   end
 
-  it 'raises when connection fails within the specified timeframe' do
+  it "raises when connection fails within the specified timeframe" do
     allow_any_instance_of(Nsq::Producer).to receive(:connected?).and_return(false)
-    logger = spy('logger')
+    logger = spy("logger")
     expect(logger).to receive(:error).and_return("Producer for #{topic} failed to connect!")
 
-    if RUBY_VERSION > '2.4.0'
-      expect { FastlyNsq::Producer.new(topic: topic, logger: logger, connect_timeout: 0.2) }.
-        to raise_error(FastlyNsq::ConnectionFailed, match(FastlyNsq.lookupd_http_addresses.inspect))
+    if RUBY_VERSION > "2.4.0"
+      expect { FastlyNsq::Producer.new(topic: topic, logger: logger, connect_timeout: 0.2) }
+        .to raise_error(FastlyNsq::ConnectionFailed, match(FastlyNsq.lookupd_http_addresses.inspect))
     else
-      expect { FastlyNsq::Producer.new(topic: topic, logger: logger, connect_timeout: 0.2) }.
-        to raise_error(FastlyNsq::ConnectionFailed)
+      expect { FastlyNsq::Producer.new(topic: topic, logger: logger, connect_timeout: 0.2) }
+        .to raise_error(FastlyNsq::ConnectionFailed)
     end
   end
 
-  describe 'faking', :fake do
+  describe "faking", :fake do
     it { should be_connected }
 
-    it 'should terminate' do
+    it "should terminate" do
       expect { subject.terminate }.to change(subject, :connected?).to(false)
       expect(subject.connection).to eq(nil)
     end
 
-    it 'writes a message' do
-      expect { subject.write 'foo' }.to change { subject.messages.size }.by(1)
+    it "writes a message" do
+      expect { subject.write "foo" }.to change { subject.messages.size }.by(1)
     end
 
-    it 'does not write after termination' do
+    it "does not write after termination" do
       subject.terminate
-      expect { subject.write 'foo' }.to raise_error(FastlyNsq::NotConnectedError)
+      expect { subject.write "foo" }.to raise_error(FastlyNsq::NotConnectedError)
     end
 
-    it 'can connect after termination' do
+    it "can connect after termination" do
       subject.terminate
       expect { subject.connect }.to change(subject, :connected?).to(true)
     end
   end
 
-  describe 'inline', :inline do
+  describe "inline", :inline do
     it { should be_connected }
 
-    it 'should terminate' do
+    it "should terminate" do
       expect { subject.terminate }.to change(subject, :connected?).to(false)
       expect(subject.connection).to eq(nil)
     end
 
-    it 'writes a message' do
-      expect { subject.write 'foo' }.to change { subject.messages.size }.by(1)
+    it "writes a message" do
+      expect { subject.write "foo" }.to change { subject.messages.size }.by(1)
     end
 
-    it 'does not write after termination' do
+    it "does not write after termination" do
       subject.terminate
-      expect { subject.write 'foo' }.to raise_error(FastlyNsq::NotConnectedError)
+      expect { subject.write "foo" }.to raise_error(FastlyNsq::NotConnectedError)
     end
 
-    it 'can connect after termination' do
+    it "can connect after termination" do
       subject.terminate
       expect { subject.connect }.to change(subject, :connected?).to(true)
     end

data/spec/spec_helper.rb

@@ -1,26 +1,26 @@
 # frozen_string_literal: true
 
-require 'dotenv'
+require "dotenv"
 Dotenv.load
 
-require 'bundler/setup'
+require "bundler/setup"
 
 Bundler.require(:development)
 
-require 'fastly_nsq'
-require 'fastly_nsq/http'
-require 'fastly_nsq/testing'
+require "fastly_nsq"
+require "fastly_nsq/http"
+require "fastly_nsq/testing"
 
-Dir[File.expand_path('../{support,shared,matchers}/**/*.rb', __FILE__)].each { |f| require(f) }
+Dir[File.expand_path("../{support,shared,matchers}/**/*.rb", __FILE__)].sort.each { |f| require(f) }
 
 FastlyNsq::Testing.disable!
 
-if ENV['DEBUG']
+if ENV["DEBUG"]
   Concurrent.use_stdlib_logger(Logger::DEBUG)
-  FastlyNsq.logger = Logger.new(STDOUT)
+  FastlyNsq.logger = Logger.new($stdout)
 else
   Concurrent.use_stdlib_logger(Logger::ERROR)
-  FastlyNsq.logger = Logger.new('/dev/null').tap { |l| l.level = Logger::DEBUG }
+  FastlyNsq.logger = Logger.new("/dev/null").tap { |l| l.level = Logger::DEBUG }
 end
 
 RSpec.configure do |config|
@@ -32,15 +32,15 @@ RSpec.configure do |config|
     mocks.verify_partial_doubles = true
   end
 
-  config.default_formatter = 'progress'
+  config.default_formatter = "progress"
   config.disable_monkey_patching!
-  config.example_status_persistence_file_path = 'spec/examples.txt'
+  config.example_status_persistence_file_path = "spec/examples.txt"
   config.filter_run :focus
   config.order = :random
   config.profile_examples = 1
   config.run_all_when_everything_filtered = true
   Kernel.srand config.seed
-  config.default_formatter = 'doc' if config.files_to_run.one?
+  config.default_formatter = "doc" if config.files_to_run.one?
 
   config.around(:each, fake: true) do |example|
     RSpec::Mocks.with_temporary_scope do

data/spec/support/http.rb

@@ -2,8 +2,8 @@
 
 module SupportHttp
   def message_count(topic)
-    topic_stats = JSON.parse(FastlyNsq::Http::Nsqd.stats(topic: topic).body)['topics'].first || {}
-    topic_stats['message_count']
+    topic_stats = JSON.parse(FastlyNsq::Http::Nsqd.stats(topic: topic).body)["topics"].first || {}
+    topic_stats["message_count"]
   end
 
   def create_topic(topic)

data/spec/support/webmock.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'webmock/rspec/matchers'
+require "webmock/rspec/matchers"
 
 RSpec.configure do |config|
   config.include WebMock::API, :webmock

data/spec/testing_spec.rb

@@ -1,29 +1,29 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe FastlyNsq::Testing do
-  describe '.message' do
-    it 'returns a FastlyNsq::Message' do
-      data = { 'foo' => 'bar' }
+  describe ".message" do
+    it "returns a FastlyNsq::Message" do
+      data = {"foo" => "bar"}
       message = FastlyNsq::Testing.message(data: data)
 
-      expect(message.body).to eq('data' => data, 'meta' => nil)
+      expect(message.body).to eq("data" => data, "meta" => nil)
     end
 
-    it 'returns a FastlyNsq::Message with meta' do
-      data = { 'foo' => 'bar' }
-      meta = 'foo'
+    it "returns a FastlyNsq::Message with meta" do
+      data = {"foo" => "bar"}
+      meta = "foo"
       message = FastlyNsq::Testing.message(data: data, meta: meta)
 
-      expect(message.body).to eq('data' => data, 'meta' => meta)
+      expect(message.body).to eq("data" => data, "meta" => meta)
     end
 
-    it 'wraps a FastlyNsq::TestMessage' do
-      data = 'bar'
+    it "wraps a FastlyNsq::TestMessage" do
+      data = "bar"
       message = FastlyNsq::Testing.message(data: data)
       expect(message.nsq_message).to be_a(FastlyNsq::TestMessage)
-      expect(message.nsq_message.body).to eq(JSON.dump('data' => data, 'meta' => nil))
+      expect(message.nsq_message.body).to eq(JSON.dump("data" => data, "meta" => nil))
     end
   end
 end