airbrake-ruby 4.15.0 → 6.1.0

data/spec/stashable_spec.rb

@@ -5,19 +5,19 @@ RSpec.describe Airbrake::Stashable do
   end
 
   describe "#stash" do
-    subject { klass.new }
+    subject(:instance) { klass.new }
 
     it "returns a hash" do
-      expect(subject.stash).to be_a(Hash)
+      expect(instance.stash).to be_a(Hash)
     end
 
     it "returns an empty hash" do
-      expect(subject.stash).to be_empty
+      expect(instance.stash).to be_empty
     end
 
     it "remembers what was put in the stash" do
-      subject.stash[:foo] = 1
-      expect(subject.stash[:foo]).to eq(1)
+      instance.stash[:foo] = 1
+      expect(instance.stash[:foo]).to eq(1)
     end
   end
 end

data/spec/stat_spec.rb

@@ -1,7 +1,9 @@
 RSpec.describe Airbrake::Stat do
+  subject(:stat) { described_class.new }
+
   describe "#to_h" do
     it "converts to a hash" do
-      expect(subject.to_h).to eq(
+      expect(stat.to_h).to eq(
         'count' => 0,
         'sum' => 0.0,
         'sumsq' => 0.0,
@@ -10,29 +12,20 @@ RSpec.describe Airbrake::Stat do
     end
   end
 
-  describe "#increment" do
-    let(:start_time) { Time.new(2018, 1, 1, 0, 0, 20, 0) }
-    let(:end_time) { Time.new(2018, 1, 1, 0, 0, 22, 0) }
-
-    before { subject.increment(start_time, end_time) }
-
-    its(:sum) { is_expected.to eq(2000) }
-  end
-
   describe "#increment_ms" do
-    before { subject.increment_ms(1000) }
+    before { stat.increment_ms(1000) }
 
     its(:sum) { is_expected.to eq(1000) }
     its(:sumsq) { is_expected.to eq(1000000) }
 
     it "updates tdigest" do
-      expect(subject.tdigest.size).to eq(1)
+      expect(stat.tdigest.size).to eq(1)
     end
   end
 
   describe "#inspect" do
     it "provides custom inspect output" do
-      expect(subject.inspect).to eq(
+      expect(stat.inspect).to eq(
         '#<struct Airbrake::Stat count=0, sum=0.0, sumsq=0.0>',
       )
     end
@@ -40,7 +33,7 @@ RSpec.describe Airbrake::Stat do
 
   describe "#pretty_print" do
     it "is an alias of #inspect" do
-      expect(subject.method(:pretty_print)).to eql(subject.method(:inspect))
+      expect(stat.method(:pretty_print)).to eql(stat.method(:inspect))
     end
   end
 end

data/spec/sync_sender_spec.rb

@@ -1,4 +1,6 @@
 RSpec.describe Airbrake::SyncSender do
+  subject(:sync_sender) { described_class.new }
+
   before do
     Airbrake::Config.instance = Airbrake::Config.new(
       project_id: 1, project_key: 'banana',
@@ -14,7 +16,7 @@ RSpec.describe Airbrake::SyncSender do
     before { stub_request(:post, endpoint).to_return(body: '{}') }
 
     it "sets the Content-Type header to JSON" do
-      subject.send({}, promise)
+      sync_sender.send({}, promise)
       expect(
         a_request(:post, endpoint).with(
           headers: { 'Content-Type' => 'application/json' },
@@ -23,18 +25,20 @@ RSpec.describe Airbrake::SyncSender do
     end
 
     it "sets the User-Agent header to the notifier slug" do
-      subject.send({}, promise)
+      sync_sender.send({}, promise)
       expect(
         a_request(:post, endpoint).with(
           headers: {
-            'User-Agent' => %r{airbrake-ruby/\d+\.\d+\.\d+ Ruby/\d+\.\d+\.\d+},
+            'User-Agent' => %r{
+              airbrake-ruby/\d+\.\d+\.\d+(\.rc\.\d+)?\sRuby/\d+\.\d+\.\d+
+            }x,
           },
         ),
       ).to have_been_made.once
     end
 
     it "sets the Authorization header to the project key" do
-      subject.send({}, promise)
+      sync_sender.send({}, promise)
       expect(
         a_request(:post, endpoint).with(
           headers: { 'Authorization' => 'Bearer banana' },
@@ -43,19 +47,46 @@ RSpec.describe Airbrake::SyncSender do
     end
 
     it "catches exceptions raised while sending" do
+      # rubocop:disable RSpec/VerifiedDoubles
       https = double("foo")
-      allow(subject).to receive(:build_https).and_return(https)
+      # rubocop:enable RSpec/VerifiedDoubles
+
+      # rubocop:disable RSpec/SubjectStub
+      allow(sync_sender).to receive(:build_https).and_return(https)
+      # rubocop:enable RSpec/SubjectStub
+
       allow(https).to receive(:request).and_raise(StandardError.new('foo'))
-      expect(Airbrake::Loggable.instance).to receive(:error).with(
+
+      expect(sync_sender.send({}, promise)).to be_an(Airbrake::Promise)
+      expect(promise.value).to eq('error' => '**Airbrake: HTTP error: foo')
+    end
+
+    it "logs exceptions raised while sending" do
+      allow(Airbrake::Loggable.instance).to receive(:error)
+
+      # rubocop:disable RSpec/VerifiedDoubles
+      https = double("foo")
+      # rubocop:enable RSpec/VerifiedDoubles
+
+      # rubocop:disable RSpec/SubjectStub
+      allow(sync_sender).to receive(:build_https).and_return(https)
+      # rubocop:enable RSpec/SubjectStub
+
+      allow(https).to receive(:request).and_raise(StandardError.new('foo'))
+
+      sync_sender.send({}, promise)
+
+      expect(Airbrake::Loggable.instance).to have_received(:error).with(
         /HTTP error: foo/,
       )
-      expect(subject.send({}, promise)).to be_an(Airbrake::Promise)
-      expect(promise.value).to eq('error' => '**Airbrake: HTTP error: foo')
     end
 
     context "when request body is nil" do
+      # rubocop:disable RSpec/MultipleExpectations
       it "doesn't send data" do
-        expect_any_instance_of(Airbrake::Truncator)
+        allow(Airbrake::Loggable.instance).to receive(:error)
+
+        allow_any_instance_of(Airbrake::Truncator)
           .to receive(:reduce_max_size).and_return(0)
 
         encoded = Base64.encode64("\xD3\xE6\xBC\x9D\xBA").encode!('ASCII-8BIT')
@@ -68,16 +99,18 @@ RSpec.describe Airbrake::SyncSender do
 
         notice = Airbrake::Notice.new(ex)
 
-        expect(Airbrake::Loggable.instance).to receive(:error).with(
+        expect(sync_sender.send(notice, promise)).to be_an(Airbrake::Promise)
+        expect(promise.value)
+          .to match('error' => '**Airbrake: data was not sent because of missing body')
+
+        expect(Airbrake::Loggable.instance).to have_received(:error).with(
           /data was not sent/,
         )
-        expect(Airbrake::Loggable.instance).to receive(:error).with(
+        expect(Airbrake::Loggable.instance).to have_received(:error).with(
           /truncation failed/,
         )
-        expect(subject.send(notice, promise)).to be_an(Airbrake::Promise)
-        expect(promise.value)
-          .to match('error' => '**Airbrake: data was not sent because of missing body')
       end
+      # rubocop:enable RSpec/MultipleExpectations
     end
 
     context "when IP is rate limited" do
@@ -91,13 +124,14 @@ RSpec.describe Airbrake::SyncSender do
         )
       end
 
+      # rubocop:disable RSpec/MultipleExpectations
       it "returns error" do
         p1 = Airbrake::Promise.new
-        subject.send({}, p1)
+        sync_sender.send({}, p1)
         expect(p1.value).to match('error' => '**Airbrake: IP is rate limited')
 
         p2 = Airbrake::Promise.new
-        subject.send({}, p2)
+        sync_sender.send({}, p2)
         expect(p2.value).to match('error' => '**Airbrake: IP is rate limited')
 
         # Wait for X-RateLimit-Delay and then make a new request to make sure p2
@@ -105,11 +139,12 @@ RSpec.describe Airbrake::SyncSender do
         sleep 1
 
         p3 = Airbrake::Promise.new
-        subject.send({}, p3)
+        sync_sender.send({}, p3)
         expect(p3.value).to match('error' => '**Airbrake: IP is rate limited')
 
         expect(a_request(:post, endpoint)).to have_been_made.twice
       end
+      # rubocop:enable RSpec/MultipleExpectations
     end
 
     context "when the provided method is :put" do

data/spec/tdigest_spec.rb

@@ -1,16 +1,18 @@
 RSpec.describe Airbrake::TDigest do
+  subject(:tdigest) { described_class.new }
+
   describe "byte serialization" do
     it "loads serialized data" do
-      subject.push(60, 100)
-      10.times { subject.push(rand * 100) }
-      bytes = subject.as_bytes
+      tdigest.push(60, 100)
+      10.times { tdigest.push(rand * 100) }
+      bytes = tdigest.as_bytes
       new_tdigest = described_class.from_bytes(bytes)
-      expect(new_tdigest.percentile(0.9)).to eq(subject.percentile(0.9))
+      expect(new_tdigest.percentile(0.9)).to eq(tdigest.percentile(0.9))
       expect(new_tdigest.as_bytes).to eq(bytes)
     end
 
     it "handles zero size" do
-      bytes = subject.as_bytes
+      bytes = tdigest.as_bytes
       expect(described_class.from_bytes(bytes).size).to be_zero
     end
 
@@ -24,76 +26,75 @@ RSpec.describe Airbrake::TDigest do
 
   describe "small byte serialization" do
     it "loads serialized data" do
-      10.times { subject.push(10) }
-      bytes = subject.as_small_bytes
+      10.times { tdigest.push(10) }
+      bytes = tdigest.as_small_bytes
       new_tdigest = described_class.from_bytes(bytes)
       # Expect some rounding error due to compression
       expect(new_tdigest.percentile(0.9).round(5)).to eq(
-        subject.percentile(0.9).round(5),
+        tdigest.percentile(0.9).round(5),
       )
       expect(new_tdigest.as_small_bytes).to eq(bytes)
     end
 
     it "handles zero size" do
-      bytes = subject.as_small_bytes
+      bytes = tdigest.as_small_bytes
       expect(described_class.from_bytes(bytes).size).to be_zero
     end
   end
 
   describe "JSON serialization" do
     it "loads serialized data" do
-      subject.push(60, 100)
-      json = subject.as_json
+      tdigest.push(60, 100)
+      json = tdigest.as_json
       new_tdigest = described_class.from_json(json)
-      expect(new_tdigest.percentile(0.9)).to eq(subject.percentile(0.9))
+      expect(new_tdigest.percentile(0.9)).to eq(tdigest.percentile(0.9))
     end
   end
 
   describe "#percentile" do
     it "returns nil if empty" do
-      expect(subject.percentile(0.90)).to be_nil # This should not crash
+      expect(tdigest.percentile(0.90)).to be_nil # This should not crash
     end
 
     it "raises ArgumentError of input not between 0 and 1" do
-      expect { subject.percentile(1.1) }.to raise_error(ArgumentError)
+      expect { tdigest.percentile(1.1) }.to raise_error(ArgumentError)
     end
 
     describe "with only single value" do
       it "returns the value" do
-        subject.push(60, 100)
-        expect(subject.percentile(0.90)).to eq(60)
+        tdigest.push(60, 100)
+        expect(tdigest.percentile(0.90)).to eq(60)
       end
 
       it "returns 0 for all percentiles when only 0 present" do
-        subject.push(0)
-        expect(subject.percentile([0.0, 0.5, 1.0])).to eq([0, 0, 0])
+        tdigest.push(0)
+        expect(tdigest.percentile([0.0, 0.5, 1.0])).to eq([0, 0, 0])
       end
     end
 
     describe "with alot of uniformly distributed points" do
       it "has minimal error" do
         seed = srand(1234) # Makes the values a proper fixture
-        N = 100_000
         maxerr = 0
-        values = Array.new(N).map { rand }
+        values = Array.new(100_000).map { rand }
         srand(seed)
 
-        subject.push(values)
-        subject.compress!
+        tdigest.push(values)
+        tdigest.compress!
 
         0.step(1, 0.1).each do |i|
-          q = subject.percentile(i)
+          q = tdigest.percentile(i)
           maxerr = [maxerr, (i - q).abs].max
         end
 
-        expect(maxerr).to be < 0.01
+        expect(maxerr).to be < 0.02
       end
     end
   end
 
   describe "#push" do
     it "calls _cumulate so won't crash because of uninitialized mean_cumn" do
-      subject.push(
+      tdigest.push(
         [
           125000000.0,
           104166666.66666666,
@@ -132,59 +133,62 @@ RSpec.describe Airbrake::TDigest do
     end
 
     it "does not blow up if data comes in sorted" do
-      subject.push(0..10_000)
-      expect(subject.centroids.size).to be < 5_000
-      subject.compress!
-      expect(subject.centroids.size).to be < 1_000
+      tdigest.push(0..10_000)
+      expect(tdigest.centroids.size).to be < 5_000
+      tdigest.compress!
+      expect(tdigest.centroids.size).to be < 1_000
     end
   end
 
   describe "#size" do
     it "reports the number of observations" do
       n = 10_000
-      n.times { subject.push(rand) }
-      subject.compress!
-      expect(subject.size).to eq(n)
+      n.times { tdigest.push(rand) }
+      tdigest.compress!
+      expect(tdigest.size).to eq(n)
     end
   end
 
   describe "#+" do
     it "works with empty tdigests" do
       other = described_class.new(0.001, 50, 1.2)
-      expect((subject + other).centroids.size).to eq(0)
+      expect((tdigest + other).centroids.size).to eq(0)
     end
 
     describe "adding two tdigests" do
+      let(:other) { described_class.new(0.001, 50, 1.2) }
+
       before do
-        @other = described_class.new(0.001, 50, 1.2)
-        [subject, @other].each do |td|
+        [tdigest, other].each do |td|
           td.push(60, 100)
           10.times { td.push(rand * 100) }
         end
       end
 
+      # rubocop:disable RSpec/MultipleExpectations
       it "has the parameters of the left argument (the calling tdigest)" do
-        new_tdigest = subject + @other
+        new_tdigest = tdigest + other
         expect(new_tdigest.instance_variable_get(:@delta)).to eq(
-          subject.instance_variable_get(:@delta),
+          tdigest.instance_variable_get(:@delta),
         )
         expect(new_tdigest.instance_variable_get(:@k)).to eq(
-          subject.instance_variable_get(:@k),
+          tdigest.instance_variable_get(:@k),
         )
         expect(new_tdigest.instance_variable_get(:@cx)).to eq(
-          subject.instance_variable_get(:@cx),
+          tdigest.instance_variable_get(:@cx),
         )
       end
+      # rubocop:enable RSpec/MultipleExpectations
 
       it "returns a tdigest with less than or equal centroids" do
-        new_tdigest = subject + @other
+        new_tdigest = tdigest + other
         expect(new_tdigest.centroids.size)
-          .to be <= subject.centroids.size + @other.centroids.size
+          .to be <= tdigest.centroids.size + other.centroids.size
       end
 
       it "has the size of the two digests combined" do
-        new_tdigest = subject + @other
-        expect(new_tdigest.size).to eq(subject.size + @other.size)
+        new_tdigest = tdigest + other
+        expect(new_tdigest.size).to eq(tdigest.size + other.size)
       end
     end
   end
@@ -192,14 +196,15 @@ RSpec.describe Airbrake::TDigest do
   describe "#merge!" do
     it "works with empty tdigests" do
       other = described_class.new(0.001, 50, 1.2)
-      subject.merge!(other)
-      expect(subject.centroids.size).to be_zero
+      tdigest.merge!(other)
+      expect(tdigest.centroids.size).to be_zero
     end
 
     describe "with populated tdigests" do
+      let(:other) { described_class.new(0.001, 50, 1.2) }
+
       before do
-        @other = described_class.new(0.001, 50, 1.2)
-        [subject, @other].each do |td|
+        [tdigest, other].each do |td|
           td.push(60, 100)
           10.times { td.push(rand * 100) }
         end
@@ -207,23 +212,23 @@ RSpec.describe Airbrake::TDigest do
 
       it "has the parameters of the calling tdigest" do
         vars = %i[@delta @k @cx]
-        expected = Hash[vars.map { |v| [v, subject.instance_variable_get(v)] }]
-        subject.merge!(@other)
+        expected = vars.map { |v| [v, tdigest.instance_variable_get(v)] }.to_h
+        tdigest.merge!(other)
         vars.each do |v|
-          expect(subject.instance_variable_get(v)).to eq(expected[v])
+          expect(tdigest.instance_variable_get(v)).to eq(expected[v])
         end
       end
 
       it "returns a tdigest with less than or equal centroids" do
-        combined_size = subject.centroids.size + @other.centroids.size
-        subject.merge!(@other)
-        expect(subject.centroids.size).to be <= combined_size
+        combined_size = tdigest.centroids.size + other.centroids.size
+        tdigest.merge!(other)
+        expect(tdigest.centroids.size).to be <= combined_size
       end
 
       it "has the size of the two digests combined" do
-        combined_size = subject.size + @other.size
-        subject.merge!(@other)
-        expect(subject.size).to eq(combined_size)
+        combined_size = tdigest.size + other.size
+        tdigest.merge!(other)
+        expect(tdigest.size).to eq(combined_size)
       end
     end
   end