airbrake-ruby 6.1.0-java → 6.1.1-java

data/spec/thread_pool_spec.rb

@@ -1,196 +0,0 @@
-RSpec.describe Airbrake::ThreadPool do
-  subject(:thread_pool) do
-    described_class.new(
-      worker_size: worker_size,
-      queue_size: queue_size,
-      block: proc { |message| tasks << message },
-    )
-  end
-
-  let(:tasks) { [] }
-  let(:worker_size) { 1 }
-  let(:queue_size) { 2 }
-
-  describe "#<<" do
-    it "returns true" do
-      retval = thread_pool << 1
-      thread_pool.close
-      expect(retval).to be(true)
-    end
-
-    it "performs work in background" do
-      thread_pool << 2
-      thread_pool << 1
-      thread_pool.close
-
-      expect(tasks).to eq([2, 1])
-    end
-
-    context "when the queue is full" do
-      subject(:full_thread_pool) do
-        described_class.new(
-          worker_size: 1,
-          queue_size: 1,
-          block: proc { |message| tasks << message },
-        )
-      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 = full_thread_pool << 1
-        full_thread_pool.close
-        expect(retval).to be(false)
-      end
-
-      it "discards tasks" do
-        200.times { full_thread_pool << 1 }
-        full_thread_pool.close
-
-        expect(tasks.size).to be_zero
-      end
-
-      it "logs discarded tasks" do
-        allow(Airbrake::Loggable.instance).to receive(:info)
-
-        15.times { full_thread_pool << 1 }
-        full_thread_pool.close
-
-        expect(Airbrake::Loggable.instance)
-          .to have_received(:info).exactly(15).times
-      end
-    end
-  end
-
-  describe "#backlog" do
-    let(:worker_size) { 0 }
-
-    it "returns the size of the queue" do
-      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
-      thread_pool.workers.list.each do |worker|
-        worker.kill.join
-      end
-      expect(thread_pool).not_to have_workers
-    end
-
-    it "returns false when the thread pool is closed" do
-      thread_pool.close
-      expect(thread_pool).not_to have_workers
-    end
-
-    describe "forking behavior" do
-      before do
-        skip('fork() is unsupported on JRuby') if %w[jruby].include?(RUBY_ENGINE)
-        unless Process.respond_to?(:last_status)
-          skip('Process.last_status is unsupported on this Ruby')
-        end
-      end
-
-      # rubocop:disable RSpec/MultipleExpectations
-      it "respawns workers on fork()" do
-        pid = fork { expect(thread_pool).to have_workers }
-        Process.wait(pid)
-        thread_pool.close
-
-        expect(Process.last_status).to be_success
-        expect(thread_pool).not_to have_workers
-      end
-      # rubocop:enable RSpec/MultipleExpectations
-
-      it "ensures that a new thread group is created per process" do
-        thread_pool << 1
-        pid = fork { thread_pool.has_workers? }
-        Process.wait(pid)
-        thread_pool.close
-
-        expect(Process.last_status).to be_success
-      end
-    end
-  end
-
-  describe "#close" do
-    context "when there's no work to do" do
-      it "joins the spawned thread" do
-        workers = thread_pool.workers.list
-        expect(workers).to all(be_alive)
-
-        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
-        allow(Airbrake::Loggable.instance).to receive(:debug)
-
-        thread_pool = described_class.new(
-          name: 'foo', worker_size: 0, queue_size: 2, block: proc {},
-        )
-
-        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
-        thread_pool = described_class.new(
-          worker_size: 1, queue_size: 2, block: proc {},
-        )
-
-        10.times { thread_pool << 1 }
-        thread_pool.close
-        expect(thread_pool.backlog).to be_zero
-      end
-    end
-
-    context "when it was already closed" do
-      it "doesn't increase the queue size" do
-        begin
-          thread_pool.close
-        rescue Airbrake::Error
-          nil
-        end
-
-        expect(thread_pool.backlog).to be_zero
-      end
-
-      it "raises error" do
-        thread_pool.close
-        expect { thread_pool.close }.to raise_error(
-          Airbrake::Error, 'this thread pool is closed already'
-        )
-      end
-    end
-  end
-
-  describe "#spawn_workers" do
-    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
-
-    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(thread_pool.workers.list.size).to eq(worker_size)
-    end
-  end
-end

data/spec/time_truncate_spec.rb

@@ -1,30 +0,0 @@
-RSpec.describe Airbrake::TimeTruncate do
-  time = Time.new(2018, 1, 1, 0, 0, 20, 0)
-  time_with_zone = Time.new(2018, 1, 1, 0, 0, 20, '-05:00')
-
-  describe "#utc_truncate_minutes" do
-    shared_examples 'time conversion' do |t|
-      it "truncates the time to the floor minute and returns an RFC3339 timestamp" do
-        expect(described_class.utc_truncate_minutes(t))
-          .to eq('2018-01-01T00:00:00+00:00')
-      end
-
-      it "converts time with zone to UTC" do
-        expect(described_class.utc_truncate_minutes(time_with_zone))
-          .to eq('2018-01-01T05:00:00+00:00')
-      end
-    end
-
-    context "when the time argument is a Time object" do
-      include_examples 'time conversion', time
-    end
-
-    context "when the time argument is a Float" do
-      include_examples 'time conversion', time.to_f
-    end
-
-    context "when the time argument is an Integer" do
-      include_examples 'time conversion', time.to_i
-    end
-  end
-end

data/spec/timed_trace_spec.rb

@@ -1,127 +0,0 @@
-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') { anything }).to be_a(described_class)
-    end
-
-    it "returns a timed trace with a stopped span" do
-      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
-      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(timed_trace.start_span('operation')).to be(true)
-      end
-    end
-
-    context "when called multiple times" do
-      before { timed_trace.start_span('operation') }
-
-      it "returns false" do
-        expect(timed_trace.start_span('operation')).to be(false)
-      end
-    end
-
-    context "when another span was started" do
-      before { timed_trace.start_span('operation') }
-
-      it "returns true" do
-        expect(timed_trace.start_span('another operation')).to be(true)
-      end
-    end
-
-    context "when #spans was called" do
-      before { timed_trace.start_span('operation') }
-
-      it "returns spans with zero values" do
-        expect(timed_trace.spans).to eq('operation' => 0.0)
-      end
-    end
-  end
-
-  describe "#stop_span" do
-    context "when #start_span wasn't invoked" do
-      it "returns false" do
-        expect(timed_trace.stop_span('operation')).to be(false)
-      end
-    end
-
-    context "when #start_span was invoked" do
-      before { timed_trace.start_span('operation') }
-
-      it "returns true" do
-        expect(timed_trace.stop_span('operation')).to be(true)
-      end
-    end
-
-    context "when multiple spans were started" do
-      before do
-        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(timed_trace.stop_span('another operation')).to be(true)
-          expect(timed_trace.stop_span('operation')).to be(true)
-        end
-      end
-
-      context "and when stopping in FIFO order" do
-        it "returns true for all spans" do
-          expect(timed_trace.stop_span('operation')).to be(true)
-          expect(timed_trace.stop_span('another operation')).to be(true)
-        end
-      end
-    end
-  end
-
-  describe "#spans" do
-    context "when no spans were captured" do
-      it "returns an empty hash" do
-        expect(timed_trace.spans).to eq({})
-      end
-    end
-
-    context "when a span was captured" do
-      before do
-        timed_trace.start_span('operation')
-        timed_trace.stop_span('operation')
-      end
-
-      it "returns a Hash with the corresponding span" do
-        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
-        timed_trace.start_span('operation')
-        timed_trace.stop_span('operation')
-
-        timed_trace.start_span('another operation')
-        timed_trace.stop_span('another operation')
-      end
-
-      it "returns a Hash with all spans" do
-        expect(timed_trace.spans).to match(
-          'operation' => be > 0,
-          'another operation' => be > 0,
-        )
-      end
-    end
-  end
-end

data/spec/truncator_spec.rb

@@ -1,267 +0,0 @@
-RSpec.describe Airbrake::Truncator do
-  def multiply_by_2_max_len(chr)
-    chr * 2 * max_len
-  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 }
-
-    context "given a frozen string" do
-      let(:object) { multiply_by_2_max_len('a') }
-
-      it "returns a new truncated frozen string" do
-        expect(truncator.length).to eq(max_len)
-        expect(truncator).to be_frozen
-      end
-    end
-
-    context "given a frozen hash of strings" do
-      let(:object) do
-        {
-          banana: multiply_by_2_max_len('a'),
-          kiwi: multiply_by_2_max_len('b'),
-          strawberry: 'c',
-          shrimp: 'd',
-        }.freeze
-      end
-
-      it "returns a hash of the same size" do
-        expect(truncator.size).to eq(max_size)
-      end
-
-      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',
-        )
-      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
-
-    context "given a frozen array of strings" do
-      let(:object) do
-        [
-          multiply_by_2_max_len('a'),
-          'b',
-          multiply_by_2_max_len('c'),
-          'd',
-        ].freeze
-      end
-
-      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
-
-      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
-
-    context "given a frozen set of strings" do
-      let(:object) do
-        Set.new([
-          multiply_by_2_max_len('a'),
-          'b',
-          multiply_by_2_max_len('c'),
-          'd',
-        ]).freeze
-      end
-
-      it "returns a set of the same size" do
-        expect(truncator.size).to eq(max_size)
-      end
-
-      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
-
-    context "given an arbitrary frozen object that responds to #to_json" do
-      let(:object) do
-        obj = Object.new
-        def obj.to_json
-          '{"object":"shrimp"}'
-        end
-        obj.freeze
-      end
-
-      it "returns a string of a max len size" do
-        expect(truncator.length).to eq(max_len)
-      end
-
-      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
-
-    context "given an arbitrary object that doesn't respond to #to_json" do
-      let(:object) do
-        obj = Object.new
-        allow(obj).to receive(:to_json)
-          .and_raise(Airbrake::Notice::JSON_EXCEPTIONS.first)
-        obj
-      end
-
-      it "converts the object to a truncated string" do
-        expect(truncator.length).to eq(max_len)
-        expect(truncator).to eq('#<O[Truncated]')
-      end
-    end
-
-    shared_examples 'self returning objects' do |object|
-      it "returns the passed object" do
-        expect(described_class.new(max_size).truncate(object)).to eql(object)
-      end
-    end
-
-    [1, true, false, :symbol, nil].each do |object|
-      include_examples 'self returning objects', object
-    end
-
-    context "given a recursive array" do
-      let(:object) do
-        a = %w[aaaaa bb]
-        a << a
-        a << 'c'
-        a
-      end
-
-      it "prevents recursion" do
-        expect(truncator).to eq(['aaa[Truncated]', 'bb', '[Circular]'])
-      end
-    end
-
-    context "given a recursive array with recursive hashes" do
-      let(:object) do
-        a = []
-        a << a
-
-        h = {}
-        h[:k] = h
-        a << h << 'aaaa'
-      end
-
-      it "prevents recursion" do
-        expect(truncator).to eq(['[Circular]', { k: '[Circular]' }, 'aaa[Truncated]'])
-        expect(truncator).to be_frozen
-      end
-    end
-
-    context "given a recursive set with recursive arrays" do
-      let(:object) do
-        s = Set.new
-        s << s
-
-        h = {}
-        h[:k] = h
-        s << h << 'aaaa'
-      end
-
-      it "prevents recursion" do
-        expect(truncator).to eq(
-          Set.new(['[Circular]', { k: '[Circular]' }, 'aaa[Truncated]']),
-        )
-        expect(truncator).to be_frozen
-      end
-    end
-
-    context "given a hash with long strings" do
-      let(:object) do
-        {
-          a: multiply_by_2_max_len('a'),
-          b: multiply_by_2_max_len('b'),
-          c: { d: multiply_by_2_max_len('d'), e: 'e' },
-        }
-      end
-
-      it "truncates the long strings" do
-        expect(truncator).to eq(
-          a: 'aaa[Truncated]', b: 'bbb[Truncated]', c: { d: 'ddd[Truncated]', e: 'e' },
-        )
-        expect(truncator).to be_frozen
-      end
-    end
-
-    context "given a string with valid unicode characters" do
-      let(:object) { "€€€€€" }
-
-      it "truncates the string" do
-        expect(truncator).to eq("€€€[Truncated]")
-      end
-    end
-
-    context "given an ASCII-8BIT string with invalid characters" do
-      let(:object) do
-        # Shenanigans to get a bad ASCII-8BIT string. Direct conversion raises error.
-        encoded = Base64.encode64("\xD3\xE6\xBC\x9D\xBA").encode!('ASCII-8BIT')
-        Base64.decode64(encoded).freeze
-      end
-
-      it "converts and truncates the string to UTF-8" do
-        expect(truncator).to eq("���[Truncated]")
-        expect(truncator).to be_frozen
-      end
-    end
-
-    context "given an array with hashes and hash-like objects with identical keys" do
-      let(:hashie) { Class.new(Hash) }
-
-      let(:object) do
-        {
-          errors: [
-            { file: 'a' },
-            { file: 'a' },
-            hashie.new.merge(file: 'bcde'),
-          ],
-        }
-      end
-
-      it "truncates values" do
-        expect(truncator).to eq(
-          errors: [
-            { file: 'a' },
-            { file: 'a' },
-            hashie.new.merge(file: 'bcd[Truncated]'),
-          ],
-        )
-        expect(truncator).to be_frozen
-      end
-    end
-  end
-end