airbrake-ruby 6.0.1-java → 6.1.1-java

data/spec/notice_notifier_spec.rb

@@ -1,361 +0,0 @@
-RSpec.describe Airbrake::NoticeNotifier do
-  subject(:notice_notifier) { described_class.new }
-
-  before do
-    Airbrake::Config.instance = Airbrake::Config.new(
-      project_id: 1,
-      project_key: 'abc',
-      logger: Logger.new('/dev/null'),
-      performance_stats: true,
-    )
-  end
-
-  describe "#new" do
-    describe "default filter addition" do
-      before { allow_any_instance_of(Airbrake::FilterChain).to receive(:add_filter) }
-
-      it "appends the context filter" do
-        expect_any_instance_of(Airbrake::FilterChain).to receive(:add_filter)
-          .with(instance_of(Airbrake::Filters::ContextFilter))
-        notice_notifier
-      end
-
-      it "appends the exception attributes filter" do
-        expect_any_instance_of(Airbrake::FilterChain).to receive(:add_filter)
-          .with(instance_of(Airbrake::Filters::ExceptionAttributesFilter))
-        notice_notifier
-      end
-    end
-  end
-
-  describe "#notify" do
-    let(:endpoint) { 'https://api.airbrake.io/api/v3/projects/1/notices' }
-
-    let(:body) do
-      {
-        'id' => '00054414-b147-6ffa-85d6-1524d83362a6',
-        'url' => 'http://localhost/locate/00054414-b147-6ffa-85d6-1524d83362a6',
-      }.to_json
-    end
-
-    before { stub_request(:post, endpoint).to_return(status: 201, body: body) }
-
-    it "returns a promise" do
-      expect(notice_notifier.notify('ex')).to be_an(Airbrake::Promise)
-      sleep 1
-    end
-
-    it "refines the notice object" do
-      notice_notifier.add_filter { |n| n[:params] = { foo: 'bar' } }
-      notice = notice_notifier.build_notice('ex')
-      notice_notifier.notify(notice)
-      expect(notice[:params]).to eq(foo: 'bar')
-      sleep 1
-    end
-
-    context "when config is invalid" do
-      before { Airbrake::Config.instance.merge(project_id: nil) }
-
-      it "returns a rejected promise" do
-        promise = notice_notifier.notify({})
-        expect(promise).to be_rejected
-      end
-    end
-
-    context "when a notice is not ignored" do
-      it "yields the notice" do
-        expect { |b| notice_notifier.notify('ex', &b) }
-          .to yield_with_args(Airbrake::Notice)
-        sleep 1
-      end
-    end
-
-    context "when a notice is ignored via a filter" do
-      before { notice_notifier.add_filter(&:ignore!) }
-
-      it "yields the notice" do
-        expect { |b| notice_notifier.notify('ex', &b) }
-          .to yield_with_args(Airbrake::Notice)
-      end
-
-      it "returns a rejected promise" do
-        value = notice_notifier.notify('ex').value
-        expect(value['error']).to match(/was marked as ignored/)
-      end
-    end
-
-    context "when a notice is ignored via an inline filter" do
-      before { notice_notifier.add_filter { raise AirbrakeTestError } }
-
-      it "doesn't invoke regular filters" do
-        expect { notice_notifier.notify('ex', &:ignore!) }.not_to raise_error
-      end
-    end
-
-    context "when async sender has workers" do
-      it "sends an exception asynchronously" do
-        expect_any_instance_of(Airbrake::AsyncSender).to receive(:send)
-        notice_notifier.notify('foo', bingo: 'bango')
-      end
-    end
-
-    context "when async sender doesn't have workers" do
-      it "sends an exception synchronously" do
-        allow_any_instance_of(Airbrake::AsyncSender)
-          .to receive(:has_workers?).and_return(false)
-        expect_any_instance_of(Airbrake::SyncSender).to receive(:send)
-
-        notice_notifier.notify('foo', bingo: 'bango')
-      end
-    end
-
-    context "when the provided environment is ignored" do
-      before do
-        Airbrake::Config.instance.merge(
-          environment: 'test',
-          ignore_environments: %w[test],
-        )
-      end
-
-      it "doesn't send an notice" do
-        expect_any_instance_of(Airbrake::AsyncSender).not_to receive(:send)
-        notice_notifier.notify('foo', bingo: 'bango')
-      end
-
-      it "returns a rejected promise" do
-        promise = notice_notifier.notify('foo', bingo: 'bango')
-        expect(promise.value).to eq('error' => "current environment 'test' is ignored")
-      end
-    end
-  end
-
-  describe "#notify_sync" do
-    let(:endpoint) { 'https://api.airbrake.io/api/v3/projects/1/notices' }
-
-    let(:body) do
-      {
-        'id' => '00054414-b147-6ffa-85d6-1524d83362a6',
-        'url' => 'http://localhost/locate/00054414-b147-6ffa-85d6-1524d83362a6',
-      }
-    end
-
-    before { stub_request(:post, endpoint).to_return(status: 201, body: body.to_json) }
-
-    it "returns a reponse hash" do
-      expect(notice_notifier.notify_sync('ex')).to eq(body)
-    end
-
-    it "refines the notice object" do
-      notice_notifier.add_filter { |n| n[:params] = { foo: 'bar' } }
-      notice = notice_notifier.build_notice('ex')
-      notice_notifier.notify_sync(notice)
-      expect(notice[:params]).to eq(foo: 'bar')
-    end
-
-    it "sends an exception synchronously" do
-      notice_notifier.notify_sync('foo', bingo: 'bango')
-      expect(
-        a_request(:post, endpoint).with(
-          body: /"params":{.*"bingo":"bango".*}/,
-        ),
-      ).to have_been_made.once
-    end
-
-    context "when a notice is not ignored" do
-      it "yields the notice" do
-        expect { |b| notice_notifier.notify_sync('ex', &b) }
-          .to yield_with_args(Airbrake::Notice)
-      end
-    end
-
-    context "when a notice is ignored via a filter" do
-      before { notice_notifier.add_filter(&:ignore!) }
-
-      it "yields the notice" do
-        expect { |b| notice_notifier.notify_sync('ex', &b) }
-          .to yield_with_args(Airbrake::Notice)
-      end
-
-      it "returns an error hash" do
-        response = notice_notifier.notify_sync('ex')
-        expect(response['error']).to match(/was marked as ignored/)
-      end
-    end
-
-    context "when a notice is ignored via an inline filter" do
-      before { notice_notifier.add_filter { raise AirbrakeTestError } }
-
-      it "doesn't invoke regular filters" do
-        expect { notice_notifier.notify('ex', &:ignore!) }.not_to raise_error
-      end
-    end
-
-    context "when the provided environment is ignored" do
-      before do
-        Airbrake::Config.instance.merge(
-          environment: 'test', ignore_environments: %w[test],
-        )
-      end
-
-      it "doesn't send an notice" do
-        expect_any_instance_of(Airbrake::SyncSender).not_to receive(:send)
-        notice_notifier.notify_sync('foo', bingo: 'bango')
-      end
-
-      it "returns an error hash" do
-        expect(notice_notifier.notify_sync('foo'))
-          .to eq('error' => "current environment 'test' is ignored")
-      end
-    end
-  end
-
-  describe "#add_filter" do
-    context "given a block" do
-      it "appends a new filter to the filter chain" do
-        notifier = notice_notifier
-        b = proc {}
-        # rubocop:disable RSpec/StubbedMock
-        expect_any_instance_of(Airbrake::FilterChain)
-          .to receive(:add_filter) { |*args| expect(args.last).to be(b) }
-        # rubocop:enable RSpec/StubbedMock
-        notifier.add_filter(&b)
-      end
-    end
-
-    context "given a class" do
-      it "appends a new filter to the filter chain" do
-        notifier = notice_notifier
-        klass = Class.new
-        expect_any_instance_of(Airbrake::FilterChain)
-          .to receive(:add_filter).with(klass)
-        notifier.add_filter(klass)
-      end
-    end
-  end
-
-  describe "#build_notice" do
-    context "when given exception is another notice" do
-      it "merges params with the notice" do
-        notice = notice_notifier.build_notice('ex')
-        other = notice_notifier.build_notice(notice, foo: 'bar')
-        expect(other[:params]).to eq(foo: 'bar')
-      end
-
-      it "returns the provided notice" do
-        notice = notice_notifier.build_notice('ex')
-        other = notice_notifier.build_notice(notice, foo: 'bar')
-        expect(other).to eq(notice)
-      end
-    end
-
-    context "when given exception is an Exception" do
-      it "prevents mutation of passed-in params hash" do
-        params = { immutable: true }
-        notice = notice_notifier.build_notice('ex', params)
-        notice[:params][:mutable] = true
-        expect(params).to eq(immutable: true)
-      end
-
-      context "and also when it doesn't have own backtrace" do
-        context "and when the generated backtrace consists only of library frames" do
-          it "returns the full generated backtrace" do
-            backtrace = [
-              "/lib/airbrake-ruby/a.rb:84:in `build_notice'",
-              "/lib/airbrake-ruby/b.rb:124:in `send_notice'",
-            ]
-            allow(Kernel).to receive(:caller).and_return(backtrace)
-
-            notice = notice_notifier.build_notice(Exception.new)
-
-            expect(notice[:errors].first[:backtrace]).to eq(
-              [
-                { file: '/lib/airbrake-ruby/a.rb', line: 84, function: 'build_notice' },
-                { file: '/lib/airbrake-ruby/b.rb', line: 124, function: 'send_notice' },
-              ],
-            )
-          end
-        end
-
-        context "and when the generated backtrace consists of mixed frames" do
-          it "returns the filtered backtrace" do
-            backtrace = [
-              "/airbrake-ruby/lib/airbrake-ruby/a.rb:84:in `b'",
-              "/airbrake-ruby/lib/foo/b.rb:84:in `build'",
-              "/airbrake-ruby/lib/bar/c.rb:124:in `send'",
-            ]
-            allow(Kernel).to receive(:caller).and_return(backtrace)
-
-            notice = notice_notifier.build_notice(Exception.new)
-
-            expect(notice[:errors].first[:backtrace]).to eq(
-              [
-                { file: '/airbrake-ruby/lib/foo/b.rb', line: 84, function: 'build' },
-                { file: '/airbrake-ruby/lib/bar/c.rb', line: 124, function: 'send' },
-              ],
-            )
-          end
-        end
-      end
-    end
-
-    # TODO: this seems to be bugged. Fix later.
-    context "when given exception is a Java exception", skip: true do
-      before do
-        allow(Airbrake::Backtrace).to receive(:java_exception?).and_return(true)
-      end
-
-      it "automatically generates the backtrace" do
-        backtrace = [
-          "org/jruby/RubyKernel.java:998:in `eval'",
-          "/ruby/stdlib/irb/workspace.rb:87:in `evaluate'",
-          "/ruby/stdlib/irb.rb:489:in `block in eval_input'",
-        ]
-        allow(Kernel).to receive(:caller).and_return(backtrace)
-
-        notice = notice_notifier.build_notice(Exception.new)
-
-        # rubocop:disable Layout/LineLength
-        expect(notice[:errors].first[:backtrace]).to eq(
-          [
-            { file: 'org/jruby/RubyKernel.java', line: 998, function: 'eval' },
-            { file: '/ruby/stdlib/irb/workspace.rb', line: 87, function: 'evaluate' },
-            { file: '/ruby/stdlib/irb.rb:489', line: 489, function: 'block in eval_input' },
-          ],
-        )
-        # rubocop:enable Layout/LineLength
-      end
-    end
-
-    context "when async sender is closed" do
-      before do
-        allow_any_instance_of(Airbrake::AsyncSender)
-          .to receive(:closed?).and_return(true)
-      end
-
-      it "raises error" do
-        expect { notice_notifier.build_notice(Exception.new('oops')) }.to raise_error(
-          Airbrake::Error,
-          "Airbrake is closed; can't build exception: Exception: oops",
-        )
-      end
-    end
-  end
-
-  describe "#close" do
-    it "sends the close message to async sender" do
-      expect_any_instance_of(Airbrake::AsyncSender).to receive(:close)
-      notice_notifier.close
-    end
-  end
-
-  describe "#configured?" do
-    it { is_expected.to be_configured }
-  end
-
-  describe "#merge_context" do
-    it "merges the provided context with the notice object" do
-      expect_any_instance_of(Hash).to receive(:merge!).with(apples: 'oranges')
-      notice_notifier.merge_context(apples: 'oranges')
-    end
-  end
-end

data/spec/notice_spec.rb

@@ -1,300 +0,0 @@
-RSpec.describe Airbrake::Notice do
-  let(:notice) { described_class.new(AirbrakeTestError.new, bingo: '1') }
-
-  describe "#to_json" do
-    context "app_version" do
-      context "when missing" do
-        before { Airbrake::Config.instance.merge(app_version: nil) }
-
-        it "doesn't include app_version" do
-          expect(notice.to_json).not_to match(/"context":{"version":"1.2.3"/)
-        end
-      end
-
-      context "when present" do
-        let(:notice) { described_class.new(AirbrakeTestError.new) }
-
-        before do
-          Airbrake::Config.instance.merge(
-            app_version: "1.2.3",
-            root_directory: "/one/two",
-          )
-        end
-
-        it "includes app_version" do
-          expect(notice.to_json).to match(/"context":{"version":"1.2.3"/)
-        end
-
-        it "includes root_directory" do
-          expect(notice.to_json).to match(%r{"rootDirectory":"/one/two"})
-        end
-      end
-    end
-
-    context "when versions is empty" do
-      it "doesn't set the 'versions' payload" do
-        expect(notice.to_json).not_to match(
-          /"context":{"versions":{"dep":"1.2.3"}}/,
-        )
-      end
-    end
-
-    context "when versions is not empty" do
-      it "sets the 'versions' payload" do
-        notice[:context][:versions] = { 'dep' => '1.2.3' }
-        expect(notice.to_json).to match(
-          /"context":{.*"versions":{"dep":"1.2.3"}.*}/,
-        )
-      end
-    end
-
-    context "truncation" do
-      shared_examples 'payloads' do |size, msg|
-        it msg do
-          ex = AirbrakeTestError.new
-
-          backtrace = []
-          size.times { backtrace << "bin/rails:3:in `<main>'" }
-          ex.set_backtrace(backtrace)
-
-          notice = described_class.new(ex)
-
-          expect(notice.to_json.bytesize).to be < 64000
-        end
-      end
-
-      max_msg = 'truncates to the max allowed size'
-
-      context "with an extremely huge payload" do
-        include_examples 'payloads', 200_000, max_msg
-      end
-
-      context "with a big payload" do
-        include_examples 'payloads', 50_000, max_msg
-      end
-
-      small_msg = "doesn't truncate it"
-
-      context "with a small payload" do
-        include_examples 'payloads', 1000, small_msg
-      end
-
-      context "with a tiny payload" do
-        include_examples 'payloads', 300, small_msg
-      end
-
-      context "when truncation failed" do
-        it "returns nil" do
-          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')
-          bad_string = Base64.decode64(encoded)
-
-          ex = AirbrakeTestError.new
-
-          backtrace = []
-          10.times { backtrace << "bin/rails:3:in `<#{bad_string}>'" }
-          ex.set_backtrace(backtrace)
-
-          notice = described_class.new(ex)
-          expect(notice.to_json).to be_nil
-        end
-      end
-
-      describe "object replacement with its string version" do
-        let(:klass) { Class.new }
-        let(:ex) { AirbrakeTestError.new }
-        let(:params) { { bingo: [Object.new, klass.new] } }
-        let(:notice) { described_class.new(ex, params) }
-
-        before do
-          backtrace = []
-          backtrace_size.times { backtrace << "bin/rails:3:in `<main>'" }
-          ex.set_backtrace(backtrace)
-        end
-
-        context "with payload within the limits" do
-          let(:backtrace_size) { 1000 }
-
-          it "doesn't happen" do
-            expect(notice.to_json)
-              .to match(/bingo":\["#<Object:.+>","#<#<Class:.+>:.+>"/)
-          end
-        end
-
-        context "with payload bigger than the limit" do
-          context "with payload within the limits" do
-            let(:backtrace_size) { 50_000 }
-
-            it "happens" do
-              expect(notice.to_json)
-                .to match(/bingo":\[".+Object.+",".+Class.+"/)
-            end
-          end
-        end
-      end
-    end
-
-    context "given a closed IO object" do
-      context "and when it is not monkey-patched by ActiveSupport" do
-        it "is not getting truncated" do
-          notice[:params] = { obj: IO.new(0).tap(&:close) }
-          expect(notice.to_json).to match(/"obj":"#<IO:0x.+>"/)
-        end
-      end
-
-      context "and when it is monkey-patched by ActiveSupport" do
-        # Instances of this class contain a closed IO object assigned to an
-        # instance variable. Normally, the JSON gem, which we depend on can
-        # parse closed IO objects. However, because ActiveSupport monkey-patches
-        # #to_json and calls #to_a on them, they raise IOError when we try to
-        # serialize them.
-        #
-        # @see https://goo.gl/0A3xNC
-        # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
-        class ObjectWithIoIvars
-          def initialize
-            @bongo = Tempfile.new('bongo').tap(&:close)
-          end
-
-          # @raise [NotImplementedError] when inside a Rails environment
-          def to_json(*)
-            raise NotImplementedError
-          end
-        end
-        # rubocop:enable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
-
-        # @see ObjectWithIoIvars
-        # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
-        class ObjectWithNestedIoIvars
-          def initialize
-            @bish = ObjectWithIoIvars.new
-          end
-
-          # @see ObjectWithIoIvars#to_json
-          def to_json(*)
-            raise NotImplementedError
-          end
-        end
-        # rubocop:enable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
-
-        context "and also when it's a closed Tempfile" do
-          it "doesn't fail" do
-            notice[:params] = { obj: Tempfile.new('bongo').tap(&:close) }
-            expect(notice.to_json).to match(/"obj":"#<(Temp)?file:0x.+>"/i)
-          end
-        end
-
-        context "and also when it's an IO ivar" do
-          it "doesn't fail" do
-            notice[:params] = { obj: ObjectWithIoIvars.new }
-            expect(notice.to_json).to match(/"obj":".+ObjectWithIoIvars.+"/)
-          end
-
-          context "and when it's deeply nested inside a hash" do
-            it "doesn't fail" do
-              notice[:params] = { a: { b: { c: ObjectWithIoIvars.new } } }
-              expect(notice.to_json).to match(
-                /"params":{"a":{"b":{"c":".+ObjectWithIoIvars.+"}}.*}/,
-              )
-            end
-          end
-
-          context "and when it's deeply nested inside an array" do
-            it "doesn't fail" do
-              notice[:params] = { a: [[ObjectWithIoIvars.new]] }
-              expect(notice.to_json).to match(
-                /"params":{"a":\[\[".+ObjectWithIoIvars.+"\]\].*}/,
-              )
-            end
-          end
-        end
-
-        context "and also when it's a non-IO ivar, which contains an IO ivar itself" do
-          it "doesn't fail" do
-            notice[:params] = { obj: ObjectWithNestedIoIvars.new }
-            expect(notice.to_json).to match(/"obj":".+ObjectWithNested.+"/)
-          end
-        end
-      end
-    end
-
-    it "overwrites the 'notifier' payload with the default values" do
-      notice[:notifier] = { name: 'bingo', bango: 'bongo' }
-
-      expect(notice.to_json)
-        .to match(/"notifier":{"name":"airbrake-ruby","version":".+","url":".+"}/)
-    end
-
-    it "always contains context/hostname" do
-      expect(notice.to_json)
-        .to match(/"context":{.*"hostname":".+".*}/)
-    end
-
-    it "defaults to the error severity" do
-      expect(notice.to_json).to match(/"context":{.*"severity":"error".*}/)
-    end
-
-    it "always contains environment/program_name" do
-      expect(notice.to_json)
-        .to match(%r|"environment":{"program_name":.+/rspec.*|)
-    end
-
-    it "contains errors" do
-      expect(notice.to_json)
-        .to match(/"errors":\[{"type":"AirbrakeTestError","message":"App crash/)
-    end
-
-    it "contains a backtrace" do
-      expect(notice.to_json)
-        .to match(%r|"backtrace":\[{"file":"/home/.+/spec/spec_helper.rb"|)
-    end
-
-    it "contains params" do
-      expect(notice.to_json).to match(/"params":{"bingo":"1"}/)
-    end
-  end
-
-  describe "#[]" do
-    it "accesses payload" do
-      expect(notice[:params]).to eq(bingo: '1')
-    end
-
-    it "raises error if notice is ignored" do
-      notice.ignore!
-      expect { notice[:params] }
-        .to raise_error(Airbrake::Error, 'cannot access ignored Airbrake::Notice')
-    end
-  end
-
-  describe "#[]=" do
-    it "sets a payload value" do
-      hash = { bingo: 'bango' }
-      notice[:params] = hash
-      expect(notice[:params]).to eq(hash)
-    end
-
-    it "raises error if notice is ignored" do
-      notice.ignore!
-      expect { notice[:params] = {} }
-        .to raise_error(Airbrake::Error, 'cannot access ignored Airbrake::Notice')
-    end
-
-    it "raises error when trying to assign unrecognized key" do
-      expect { notice[:bingo] = 1 }
-        .to raise_error(Airbrake::Error, /:bingo is not recognized among/)
-    end
-
-    it "raises when setting non-hash objects as the value" do
-      expect { notice[:params] = Object.new }
-        .to raise_error(Airbrake::Error, 'Got Object value, wanted a Hash')
-    end
-  end
-
-  describe "#stash" do
-    subject { described_class.new(AirbrakeTestError.new) }
-
-    it { is_expected.to respond_to(:stash) }
-  end
-end

data/spec/performance_breakdown_spec.rb

@@ -1,11 +0,0 @@
-RSpec.describe Airbrake::PerformanceBreakdown do
-  describe "#stash" do
-    subject do
-      described_class.new(
-        method: 'GET', route: '/', response_type: '', groups: {},
-      )
-    end
-
-    it { is_expected.to respond_to(:stash) }
-  end
-end