fastly_nsq 1.16.0 → 1.18.0

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)

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,87 +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)}
+
+      meta[:originating_service] = "other_service"
+
+      subject.producers["topic"] = producer
+
+      subject.deliver message: message, topic: "topic", meta: meta, originating_service: origin
+
+      expect(producer).to have_received(:write).with(expected_attributes.to_json)
+    end
 
-      expected_attributes = { data: message, meta: meta.merge(originating_service: origin, sent_at: sent_at) }
+    it "can set the sent_at in the metadata" do
+      sent_at = Time.parse("2020-06-08 23:42:42")
+      meta = {}
 
-      meta[:originating_service] = 'other_service'
+      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', 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)
 
@@ -116,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 } }