airbrake-ruby 4.6.0

data/spec/notice_notifier_spec/options_spec.rb

@@ -0,0 +1,259 @@
+RSpec.describe Airbrake::NoticeNotifier do
+  let(:project_id) { 105138 }
+  let(:project_key) { 'fd04e13d806a90f96614ad8e529b2822' }
+  let(:localhost) { 'http://localhost:8080' }
+
+  let(:endpoint) do
+    "https://api.airbrake.io/api/v3/projects/#{project_id}/notices"
+  end
+
+  let(:params) { {} }
+  let(:ex) { AirbrakeTestError.new }
+
+  before do
+    stub_request(:post, endpoint).to_return(status: 201, body: '{}')
+
+    Airbrake::Config.instance = Airbrake::Config.new(
+      project_id: project_id,
+      project_key: project_key
+    )
+  end
+
+  describe "options" do
+    describe ":host" do
+      context "when custom" do
+        shared_examples 'endpoint' do |host, endpoint, title|
+          before { Airbrake::Config.instance.merge(host: host) }
+
+          example(title) do
+            stub_request(:post, endpoint).to_return(status: 201, body: '{}')
+            subject.notify_sync(ex)
+
+            expect(a_request(:post, endpoint)).to have_been_made.once
+          end
+        end
+
+        path = '/api/v3/projects/105138/notices'
+
+        context "given a full host" do
+          include_examples('endpoint', localhost = 'http://localhost:8080',
+                           URI.join(localhost, path),
+                           "sends notices to the specified host's endpoint")
+        end
+
+        context "given a full host" do
+          include_examples('endpoint', localhost = 'http://localhost',
+                           URI.join(localhost, path),
+                           "assumes port 80 by default")
+        end
+
+        context "given a host without scheme" do
+          include_examples 'endpoint', localhost = 'localhost:8080',
+                           URI.join("https://#{localhost}", path),
+                           "assumes https by default"
+        end
+
+        context "given only hostname" do
+          include_examples 'endpoint', localhost = 'localhost',
+                           URI.join("https://#{localhost}", path),
+                           "assumes https and port 80 by default"
+        end
+      end
+    end
+
+    describe ":root_directory" do
+      before do
+        subject.add_filter(
+          Airbrake::Filters::RootDirectoryFilter.new('/home/kyrylo/code')
+        )
+      end
+
+      it "filters out frames" do
+        subject.notify_sync(ex)
+
+        expect(
+          a_request(:post, endpoint)
+          .with(body: %r|{"file":"/PROJECT_ROOT/airbrake/ruby/spec/airbrake_spec.+|)
+        ).to have_been_made.once
+      end
+
+      context "when present and is a" do
+        shared_examples 'root directory' do |dir|
+          before { Airbrake::Config.instance.merge(root_directory: dir) }
+
+          it "being included into the notice's payload" do
+            subject.notify_sync(ex)
+            expect(
+              a_request(:post, endpoint)
+              .with(body: %r{"rootDirectory":"/bingo/bango"})
+            ).to have_been_made.once
+          end
+        end
+
+        context "String" do
+          include_examples 'root directory', '/bingo/bango'
+        end
+
+        context "Pathname" do
+          include_examples 'root directory', Pathname.new('/bingo/bango')
+        end
+      end
+    end
+
+    describe ":proxy" do
+      let(:proxy) do
+        WEBrick::HTTPServer.new(
+          Port: 0,
+          Logger: WEBrick::Log.new('/dev/null'),
+          AccessLog: []
+        )
+      end
+
+      let(:requests) { Queue.new }
+
+      let(:proxy_params) do
+        { host: 'localhost',
+          port: proxy.config[:Port],
+          user: 'user',
+          password: 'password' }
+      end
+
+      before do
+        Airbrake::Config.instance.merge(
+          proxy: proxy_params,
+          host: "http://localhost:#{proxy.config[:Port]}"
+        )
+
+        proxy.mount_proc '/' do |req, res|
+          requests << req
+          res.status = 201
+          res.body = "OK\n"
+        end
+
+        Thread.new { proxy.start }
+      end
+
+      after { proxy.stop }
+
+      it "is being used if configured" do
+        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.6.0")
+          skip(
+            "We use Webmock 2, which doesn't support Ruby 2.6+. It's " \
+            "safe to run this test on 2.6+ once we upgrade to Webmock 3.5+"
+          )
+        end
+        subject.notify_sync(ex)
+
+        proxied_request = requests.pop(true)
+
+        expect(proxied_request.header['proxy-authorization'].first)
+          .to eq('Basic dXNlcjpwYXNzd29yZA==')
+
+        # rubocop:disable Metrics/LineLength
+        expect(proxied_request.request_line)
+          .to eq("POST http://localhost:#{proxy.config[:Port]}/api/v3/projects/105138/notices HTTP/1.1\r\n")
+        # rubocop:enable Metrics/LineLength
+      end
+    end
+
+    describe ":environment" do
+      context "when present" do
+        before { Airbrake::Config.instance.merge(environment: :production) }
+
+        it "being included into the notice's payload" do
+          subject.notify_sync(ex)
+          expect(
+            a_request(:post, endpoint)
+            .with(body: /"context":{.*"environment":"production".*}/)
+          ).to have_been_made.once
+        end
+      end
+    end
+
+    describe ":ignore_environments" do
+      shared_examples 'sent notice' do |params|
+        before { Airbrake::Config.instance.merge(params) }
+
+        it "sends a notice" do
+          subject.notify_sync(ex)
+          expect(a_request(:post, endpoint)).to have_been_made
+        end
+      end
+
+      shared_examples 'ignored notice' do |params|
+        before { Airbrake::Config.instance.merge(params) }
+
+        it "ignores exceptions occurring in envs that were not configured" do
+          subject.notify_sync(ex)
+          expect(a_request(:post, endpoint)).not_to have_been_made
+        end
+      end
+
+      context "when env is set and ignore_environments doesn't mention it" do
+        params = {
+          environment: :development,
+          ignore_environments: [:production]
+        }
+
+        include_examples 'sent notice', params
+      end
+
+      context "when the current env and notify envs are the same" do
+        params = {
+          environment: :development,
+          ignore_environments: %i[production development]
+        }
+
+        include_examples 'ignored notice', params
+
+        it "returns early and doesn't try to parse the given exception" do
+          expect(Airbrake::Notice).not_to receive(:new)
+          expect(subject.notify_sync(ex))
+            .to eq('error' => "current environment 'development' is ignored")
+          expect(a_request(:post, endpoint)).not_to have_been_made
+        end
+      end
+
+      context "when the current env is not set and notify envs are present" do
+        params = { ignore_environments: %i[production development] }
+
+        include_examples 'sent notice', params
+      end
+
+      context "when the current env is set and notify envs aren't" do
+        include_examples 'sent notice', environment: :development
+      end
+
+      context "when ignore_environments specifies a Regexp pattern" do
+        params = {
+          environment: :testing,
+          ignore_environments: ['staging', /test.+/]
+        }
+
+        include_examples 'ignored notice', params
+      end
+    end
+
+    describe ":blacklist_keys" do
+      # Fixes https://github.com/airbrake/airbrake-ruby/issues/276
+      context "when specified along with :whitelist_keys" do
+        context "and when context payload is present" do
+          before do
+            Airbrake::Config.instance.merge(
+              blacklist_keys: %i[password password_confirmation],
+              whitelist_keys: [:email, /user/i, 'account_id']
+            )
+          end
+
+          it "sends a notice" do
+            notice = subject.build_notice(ex)
+            notice[:context][:headers] = 'banana'
+            subject.notify_sync(notice)
+
+            expect(a_request(:post, endpoint)).to have_been_made
+          end
+        end
+      end
+    end
+  end
+end

data/spec/notice_spec.rb

@@ -0,0 +1,296 @@
+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
+          expect_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
+        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
+
+        # @see ObjectWithIoIvars
+        class ObjectWithNestedIoIvars
+          def initialize
+            @bish = ObjectWithIoIvars.new
+          end
+
+          # @see ObjectWithIoIvars#to_json
+          def to_json(*)
+            raise NotImplementedError
+          end
+        end
+
+        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 equal(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