airbrake-ruby 5.2.0-java → 5.2.1-java

data/spec/thread_pool_spec.rb

@@ -1,9 +1,5 @@
 RSpec.describe Airbrake::ThreadPool do
-  let(:tasks) { [] }
-  let(:worker_size) { 1 }
-  let(:queue_size) { 2 }
-
-  subject do
+  subject(:thread_pool) do
     described_class.new(
       worker_size: worker_size,
       queue_size: queue_size,
@@ -11,27 +7,27 @@ RSpec.describe Airbrake::ThreadPool do
     )
   end
 
+  let(:tasks) { [] }
+  let(:worker_size) { 1 }
+  let(:queue_size) { 2 }
+
   describe "#<<" do
     it "returns true" do
-      retval = subject << 1
-      subject.close
+      retval = thread_pool << 1
+      thread_pool.close
       expect(retval).to eq(true)
     end
 
     it "performs work in background" do
-      subject << 2
-      subject << 1
-      subject.close
+      thread_pool << 2
+      thread_pool << 1
+      thread_pool.close
 
       expect(tasks).to eq([2, 1])
     end
 
     context "when the queue is full" do
-      before do
-        allow(subject).to receive(:backlog).and_return(queue_size)
-      end
-
-      subject do
+      subject(:full_thread_pool) do
         described_class.new(
           worker_size: 1,
           queue_size: 1,
@@ -39,26 +35,34 @@ RSpec.describe Airbrake::ThreadPool do
         )
       end
 
+      before do
+        # rubocop:disable RSpec/SubjectStub
+        allow(full_thread_pool).to receive(:backlog).and_return(queue_size)
+        # rubocop:enable RSpec/SubjectStub
+      end
+
       it "returns false" do
-        retval = subject << 1
-        subject.close
+        retval = full_thread_pool << 1
+        full_thread_pool.close
         expect(retval).to eq(false)
       end
 
       it "discards tasks" do
-        200.times { subject << 1 }
-        subject.close
+        200.times { full_thread_pool << 1 }
+        full_thread_pool.close
 
         expect(tasks.size).to be_zero
       end
 
       it "logs discarded tasks" do
-        expect(Airbrake::Loggable.instance).to receive(:error).with(
+        allow(Airbrake::Loggable.instance).to receive(:error)
+
+        15.times { full_thread_pool << 1 }
+        full_thread_pool.close
+
+        expect(Airbrake::Loggable.instance).to have_received(:error).with(
           /reached its capacity/,
         ).exactly(15).times
-
-        15.times { subject << 1 }
-        subject.close
       end
     end
   end
@@ -67,22 +71,22 @@ RSpec.describe Airbrake::ThreadPool do
     let(:worker_size) { 0 }
 
     it "returns the size of the queue" do
-      subject << 1
-      expect(subject.backlog).to eq(1)
+      thread_pool << 1
+      expect(thread_pool.backlog).to eq(1)
     end
   end
 
   describe "#has_workers?" do
     it "returns false when the thread pool is not closed, but has 0 workers" do
-      subject.workers.list.each do |worker|
+      thread_pool.workers.list.each do |worker|
         worker.kill.join
       end
-      expect(subject).not_to have_workers
+      expect(thread_pool).not_to have_workers
     end
 
     it "returns false when the thread pool is closed" do
-      subject.close
-      expect(subject).not_to have_workers
+      thread_pool.close
+      expect(thread_pool).not_to have_workers
     end
 
     describe "forking behavior" do
@@ -93,20 +97,22 @@ RSpec.describe Airbrake::ThreadPool do
         end
       end
 
+      # rubocop:disable RSpec/MultipleExpectations
       it "respawns workers on fork()" do
-        pid = fork { expect(subject).to have_workers }
+        pid = fork { expect(thread_pool).to have_workers }
         Process.wait(pid)
-        subject.close
+        thread_pool.close
 
         expect(Process.last_status).to be_success
-        expect(subject).not_to have_workers
+        expect(thread_pool).not_to have_workers
       end
+      # rubocop:enable RSpec/MultipleExpectations
 
       it "ensures that a new thread group is created per process" do
-        subject << 1
-        pid = fork { subject.has_workers? }
+        thread_pool << 1
+        pid = fork { thread_pool.has_workers? }
         Process.wait(pid)
-        subject.close
+        thread_pool.close
 
         expect(Process.last_status).to be_success
       end
@@ -116,27 +122,29 @@ RSpec.describe Airbrake::ThreadPool do
   describe "#close" do
     context "when there's no work to do" do
       it "joins the spawned thread" do
-        workers = subject.workers.list
+        workers = thread_pool.workers.list
         expect(workers).to all(be_alive)
 
-        subject.close
+        thread_pool.close
         expect(workers).to all(be_stop)
       end
     end
 
     context "when there's some work to do" do
       it "logs how many tasks are left to process" do
-        thread_pool = described_class.new(
-          worker_size: 0, queue_size: 2, block: proc {},
-        )
+        allow(Airbrake::Loggable.instance).to receive(:debug)
 
-        expect(Airbrake::Loggable.instance).to receive(:debug).with(
-          /waiting to process \d+ task\(s\)/,
+        thread_pool = described_class.new(
+          name: 'foo', worker_size: 0, queue_size: 2, block: proc {},
         )
-        expect(Airbrake::Loggable.instance).to receive(:debug).with(/closed/)
 
         2.times { thread_pool << 1 }
         thread_pool.close
+
+        expect(Airbrake::Loggable.instance).to have_received(:debug).with(
+          /waiting to process \d+ task\(s\)/,
+        )
+        expect(Airbrake::Loggable.instance).to have_received(:debug).with(/foo.+closed/)
       end
 
       it "waits until the queue gets empty" do
@@ -144,7 +152,7 @@ RSpec.describe Airbrake::ThreadPool do
           worker_size: 1, queue_size: 2, block: proc {},
         )
 
-        10.times { subject << 1 }
+        10.times { thread_pool << 1 }
         thread_pool.close
         expect(thread_pool.backlog).to be_zero
       end
@@ -153,17 +161,17 @@ RSpec.describe Airbrake::ThreadPool do
     context "when it was already closed" do
       it "doesn't increase the queue size" do
         begin
-          subject.close
+          thread_pool.close
         rescue Airbrake::Error
           nil
         end
 
-        expect(subject.backlog).to be_zero
+        expect(thread_pool.backlog).to be_zero
       end
 
       it "raises error" do
-        subject.close
-        expect { subject.close }.to raise_error(
+        thread_pool.close
+        expect { thread_pool.close }.to raise_error(
           Airbrake::Error, 'this thread pool is closed already'
         )
       end
@@ -171,17 +179,19 @@ RSpec.describe Airbrake::ThreadPool do
   end
 
   describe "#spawn_workers" do
-    it "spawns alive threads in an enclosed ThreadGroup" do
-      expect(subject.workers).to be_a(ThreadGroup)
-      expect(subject.workers.list).to all(be_alive)
-      expect(subject.workers).to be_enclosed
+    after { thread_pool.close }
+
+    it "spawns an enclosed thread group" do
+      expect(thread_pool.workers).to be_a(ThreadGroup)
+      expect(thread_pool.workers).to be_enclosed
+    end
 
-      subject.close
+    it "spawns threads that are alive" do
+      expect(thread_pool.workers.list).to all(be_alive)
     end
 
     it "spawns exactly `workers_size` workers" do
-      expect(subject.workers.list.size).to eq(worker_size)
-      subject.close
+      expect(thread_pool.workers.list.size).to eq(worker_size)
     end
   end
 end

data/spec/time_truncate_spec.rb

@@ -2,12 +2,14 @@ RSpec.describe Airbrake::TimeTruncate do
   describe "#utc_truncate_minutes" do
     it "truncates time to the floor minute and returns an RFC3339 timestamp" do
       time = Time.new(2018, 1, 1, 0, 0, 20, 0)
-      expect(subject.utc_truncate_minutes(time)).to eq('2018-01-01T00:00:00+00:00')
+      expect(described_class.utc_truncate_minutes(time))
+        .to eq('2018-01-01T00:00:00+00:00')
     end
 
     it "converts time with zone to UTC" do
       time = Time.new(2018, 1, 1, 0, 0, 20, '-05:00')
-      expect(subject.utc_truncate_minutes(time)).to eq('2018-01-01T05:00:00+00:00')
+      expect(described_class.utc_truncate_minutes(time))
+        .to eq('2018-01-01T05:00:00+00:00')
     end
   end
 end

data/spec/timed_trace_spec.rb

@@ -1,50 +1,52 @@
 RSpec.describe Airbrake::TimedTrace do
+  subject(:timed_trace) { described_class.new }
+
   describe ".span" do
     it "returns a timed trace" do
-      expect(described_class.span('operation') {}).to be_a(described_class)
+      expect(described_class.span('operation') { anything }).to be_a(described_class)
     end
 
     it "returns a timed trace with a stopped span" do
-      timed_trace = described_class.span('operation') {}
+      timed_trace = described_class.span('operation') { anything }
       expect(timed_trace.spans).to match('operation' => be > 0)
     end
   end
 
   describe "#span" do
     it "captures a span" do
-      subject.span('operation') {}
-      expect(subject.spans).to match('operation' => be > 0)
+      timed_trace.span('operation') { anything }
+      expect(timed_trace.spans).to match('operation' => be > 0)
     end
   end
 
   describe "#start_span" do
     context "when called once" do
       it "returns true" do
-        expect(subject.start_span('operation')).to eq(true)
+        expect(timed_trace.start_span('operation')).to eq(true)
       end
     end
 
     context "when called multiple times" do
-      before { subject.start_span('operation') }
+      before { timed_trace.start_span('operation') }
 
       it "returns false" do
-        expect(subject.start_span('operation')).to eq(false)
+        expect(timed_trace.start_span('operation')).to eq(false)
       end
     end
 
     context "when another span was started" do
-      before { subject.start_span('operation') }
+      before { timed_trace.start_span('operation') }
 
       it "returns true" do
-        expect(subject.start_span('another operation')).to eq(true)
+        expect(timed_trace.start_span('another operation')).to eq(true)
       end
     end
 
     context "when #spans was called" do
-      before { subject.start_span('operation') }
+      before { timed_trace.start_span('operation') }
 
       it "returns spans with zero values" do
-        expect(subject.spans).to eq('operation' => 0.0)
+        expect(timed_trace.spans).to eq('operation' => 0.0)
       end
     end
   end
@@ -52,35 +54,35 @@ RSpec.describe Airbrake::TimedTrace do
   describe "#stop_span" do
     context "when #start_span wasn't invoked" do
       it "returns false" do
-        expect(subject.stop_span('operation')).to eq(false)
+        expect(timed_trace.stop_span('operation')).to eq(false)
       end
     end
 
     context "when #start_span was invoked" do
-      before { subject.start_span('operation') }
+      before { timed_trace.start_span('operation') }
 
       it "returns true" do
-        expect(subject.stop_span('operation')).to eq(true)
+        expect(timed_trace.stop_span('operation')).to eq(true)
       end
     end
 
     context "when multiple spans were started" do
       before do
-        subject.start_span('operation')
-        subject.start_span('another operation')
+        timed_trace.start_span('operation')
+        timed_trace.start_span('another operation')
       end
 
       context "and when stopping in LIFO order" do
         it "returns true for all spans" do
-          expect(subject.stop_span('another operation')).to eq(true)
-          expect(subject.stop_span('operation')).to eq(true)
+          expect(timed_trace.stop_span('another operation')).to eq(true)
+          expect(timed_trace.stop_span('operation')).to eq(true)
         end
       end
 
       context "and when stopping in FIFO order" do
         it "returns true for all spans" do
-          expect(subject.stop_span('operation')).to eq(true)
-          expect(subject.stop_span('another operation')).to eq(true)
+          expect(timed_trace.stop_span('operation')).to eq(true)
+          expect(timed_trace.stop_span('another operation')).to eq(true)
         end
       end
     end
@@ -89,33 +91,33 @@ RSpec.describe Airbrake::TimedTrace do
   describe "#spans" do
     context "when no spans were captured" do
       it "returns an empty hash" do
-        expect(subject.spans).to eq({})
+        expect(timed_trace.spans).to eq({})
       end
     end
 
     context "when a span was captured" do
       before do
-        subject.start_span('operation')
-        subject.stop_span('operation')
+        timed_trace.start_span('operation')
+        timed_trace.stop_span('operation')
       end
 
       it "returns a Hash with the corresponding span" do
-        subject.stop_span('operation')
-        expect(subject.spans).to match('operation' => be > 0)
+        timed_trace.stop_span('operation')
+        expect(timed_trace.spans).to match('operation' => be > 0)
       end
     end
 
     context "when multiple spans were captured" do
       before do
-        subject.start_span('operation')
-        subject.stop_span('operation')
+        timed_trace.start_span('operation')
+        timed_trace.stop_span('operation')
 
-        subject.start_span('another operation')
-        subject.stop_span('another operation')
+        timed_trace.start_span('another operation')
+        timed_trace.stop_span('another operation')
       end
 
       it "returns a Hash with all spans" do
-        expect(subject.spans).to match(
+        expect(timed_trace.spans).to match(
           'operation' => be > 0,
           'another operation' => be > 0,
         )

data/spec/truncator_spec.rb

@@ -4,18 +4,18 @@ RSpec.describe Airbrake::Truncator do
   end
 
   describe "#truncate" do
+    subject(:truncator) { described_class.new(max_size).truncate(object) }
+
     let(:max_size) { 3 }
     let(:truncated) { '[Truncated]' }
     let(:max_len) { max_size + truncated.length }
 
-    subject { described_class.new(max_size).truncate(object) }
-
     context "given a frozen string" do
       let(:object) { multiply_by_2_max_len('a') }
 
       it "returns a new truncated frozen string" do
-        expect(subject.length).to eq(max_len)
-        expect(subject).to be_frozen
+        expect(truncator.length).to eq(max_len)
+        expect(truncator).to be_frozen
       end
     end
 
@@ -29,16 +29,27 @@ RSpec.describe Airbrake::Truncator do
         }.freeze
       end
 
-      it "returns a new truncated frozen hash" do
-        expect(subject.size).to eq(max_size)
-        expect(subject).to be_frozen
+      it "returns a hash of the same size" do
+        expect(truncator.size).to eq(max_size)
+      end
 
-        expect(subject).to eq(
+      it "returns a frozen hash" do
+        expect(truncator).to be_frozen
+      end
+
+      it "returns a hash with truncated values" do
+        expect(truncator).to eq(
           banana: 'aaa[Truncated]', kiwi: 'bbb[Truncated]', strawberry: 'c',
         )
-        expect(subject[:banana]).to be_frozen
-        expect(subject[:kiwi]).to be_frozen
-        expect(subject[:strawberry]).not_to be_frozen
+      end
+
+      it "returns a hash with truncated strings that are frozen" do
+        expect(truncator[:banana]).to be_frozen
+        expect(truncator[:kiwi]).to be_frozen
+      end
+
+      it "returns a hash unfrozen untruncated strings" do
+        expect(truncator[:strawberry]).not_to be_frozen
       end
     end
 
@@ -52,14 +63,25 @@ RSpec.describe Airbrake::Truncator do
         ].freeze
       end
 
-      it "returns a new truncated frozen array" do
-        expect(subject.size).to eq(max_size)
-        expect(subject).to be_frozen
+      it "returns an array of the same size" do
+        expect(truncator.size).to eq(max_size)
+      end
+
+      it "returns a frozen array" do
+        expect(truncator).to be_frozen
+      end
 
-        expect(subject).to eq(['aaa[Truncated]', 'b', 'ccc[Truncated]'])
-        expect(subject[0]).to be_frozen
-        expect(subject[1]).not_to be_frozen
-        expect(subject[2]).to be_frozen
+      it "returns an array with truncated values" do
+        expect(truncator).to eq(['aaa[Truncated]', 'b', 'ccc[Truncated]'])
+      end
+
+      it "returns an array with truncated strings that are frozen" do
+        expect(truncator[0]).to be_frozen
+        expect(truncator[2]).to be_frozen
+      end
+
+      it "returns an array with unfrozen untruncated strings" do
+        expect(truncator[1]).not_to be_frozen
       end
     end
 
@@ -73,14 +95,16 @@ RSpec.describe Airbrake::Truncator do
         ]).freeze
       end
 
-      it "returns a new truncated frozen array" do
-        expect(subject.size).to eq(max_size)
-        expect(subject).to be_frozen
+      it "returns a set of the same size" do
+        expect(truncator.size).to eq(max_size)
+      end
 
-        expect(subject).to eq(
-          Set.new(['aaa[Truncated]', 'b', 'ccc[Truncated]']),
-        )
-        expect(subject).to be_frozen
+      it "returns a frozen set" do
+        expect(truncator).to be_frozen
+      end
+
+      it "returns a set with truncated values" do
+        expect(truncator).to eq(Set.new(['aaa[Truncated]', 'b', 'ccc[Truncated]']))
       end
     end
 
@@ -93,11 +117,16 @@ RSpec.describe Airbrake::Truncator do
         obj.freeze
       end
 
-      it "converts the object to truncated JSON" do
-        expect(subject.length).to eq(max_len)
-        expect(subject).to be_frozen
+      it "returns a string of a max len size" do
+        expect(truncator.length).to eq(max_len)
+      end
 
-        expect(subject).to eq('{"o[Truncated]')
+      it "returns a frozen object" do
+        expect(truncator).to be_frozen
+      end
+
+      it "converts the object to truncated JSON" do
+        expect(truncator).to eq('{"o[Truncated]')
       end
     end
 
@@ -110,8 +139,8 @@ RSpec.describe Airbrake::Truncator do
       end
 
       it "converts the object to a truncated string" do
-        expect(subject.length).to eq(max_len)
-        expect(subject).to eq('#<O[Truncated]')
+        expect(truncator.length).to eq(max_len)
+        expect(truncator).to eq('#<O[Truncated]')
       end
     end
 
@@ -134,7 +163,7 @@ RSpec.describe Airbrake::Truncator do
       end
 
       it "prevents recursion" do
-        expect(subject).to eq(['aaa[Truncated]', 'bb', '[Circular]'])
+        expect(truncator).to eq(['aaa[Truncated]', 'bb', '[Circular]'])
       end
     end
 
@@ -149,8 +178,8 @@ RSpec.describe Airbrake::Truncator do
       end
 
       it "prevents recursion" do
-        expect(subject).to eq(['[Circular]', { k: '[Circular]' }, 'aaa[Truncated]'])
-        expect(subject).to be_frozen
+        expect(truncator).to eq(['[Circular]', { k: '[Circular]' }, 'aaa[Truncated]'])
+        expect(truncator).to be_frozen
       end
     end
 
@@ -165,10 +194,10 @@ RSpec.describe Airbrake::Truncator do
       end
 
       it "prevents recursion" do
-        expect(subject).to eq(
+        expect(truncator).to eq(
           Set.new(['[Circular]', { k: '[Circular]' }, 'aaa[Truncated]']),
         )
-        expect(subject).to be_frozen
+        expect(truncator).to be_frozen
       end
     end
 
@@ -182,10 +211,10 @@ RSpec.describe Airbrake::Truncator do
       end
 
       it "truncates the long strings" do
-        expect(subject).to eq(
+        expect(truncator).to eq(
           a: 'aaa[Truncated]', b: 'bbb[Truncated]', c: { d: 'ddd[Truncated]', e: 'e' },
         )
-        expect(subject).to be_frozen
+        expect(truncator).to be_frozen
       end
     end
 
@@ -193,7 +222,7 @@ RSpec.describe Airbrake::Truncator do
       let(:object) { "€€€€€" }
 
       it "truncates the string" do
-        expect(subject).to eq("€€€[Truncated]")
+        expect(truncator).to eq("€€€[Truncated]")
       end
     end
 
@@ -205,8 +234,8 @@ RSpec.describe Airbrake::Truncator do
       end
 
       it "converts and truncates the string to UTF-8" do
-        expect(subject).to eq("���[Truncated]")
-        expect(subject).to be_frozen
+        expect(truncator).to eq("���[Truncated]")
+        expect(truncator).to be_frozen
       end
     end
 
@@ -224,14 +253,14 @@ RSpec.describe Airbrake::Truncator do
       end
 
       it "truncates values" do
-        expect(subject).to eq(
+        expect(truncator).to eq(
           errors: [
             { file: 'a' },
             { file: 'a' },
             hashie.new.merge(file: 'bcd[Truncated]'),
           ],
         )
-        expect(subject).to be_frozen
+        expect(truncator).to be_frozen
       end
     end
   end