airbrake-ruby 3.2.2-java

data/lib/airbrake-ruby/version.rb

@@ -0,0 +1,6 @@
+# We use Semantic Versioning v2.0.0
+# More information: http://semver.org/
+module Airbrake
+  # @return [String] the library version
+  AIRBRAKE_RUBY_VERSION = '3.2.2'.freeze
+end

data/spec/airbrake_spec.rb

@@ -0,0 +1,171 @@
+RSpec.describe Airbrake do
+  describe ".[]" do
+    it "returns a NilNotifier" do
+      expect(described_class[:test]).to be_an(Airbrake::NilNoticeNotifier)
+    end
+  end
+
+  describe ".notifiers" do
+    it "returns a Hash of notifiers" do
+      expect(described_class.notifiers).to eq(
+        notice: {}, performance: {}, deploy: {}
+      )
+    end
+  end
+
+  let(:default_notifier) do
+    described_class[:default]
+  end
+
+  describe ".configure" do
+    let(:config_params) { { project_id: 1, project_key: 'abc' } }
+
+    after do
+      described_class.instance_variable_get(:@notice_notifiers).clear
+      described_class.instance_variable_get(:@performance_notifiers).clear
+      described_class.instance_variable_get(:@deploy_notifiers).clear
+    end
+
+    it "yields the config" do
+      expect do |b|
+        begin
+          described_class.configure(&b)
+        rescue Airbrake::Error
+          nil
+        end
+      end.to yield_with_args(Airbrake::Config)
+    end
+
+    context "when invoked with a notice notifier name" do
+      it "sets notice notifier name to the provided name" do
+        described_class.configure(:test) { |c| c.merge(config_params) }
+        expect(described_class[:test]).to be_an(Airbrake::NoticeNotifier)
+      end
+    end
+
+    context "when invoked without a notifier name" do
+      it "defaults to the :default notifier name" do
+        described_class.configure { |c| c.merge(config_params) }
+        expect(described_class[:default]).to be_an(Airbrake::NoticeNotifier)
+      end
+    end
+
+    context "when invoked twice with the same notifier name" do
+      it "raises Airbrake::Error" do
+        described_class.configure { |c| c.merge(config_params) }
+        expect do
+          described_class.configure { |c| c.merge(config_params) }
+        end.to raise_error(
+          Airbrake::Error, "the 'default' notifier was already configured"
+        )
+      end
+    end
+
+    context "when user config doesn't contain a project id" do
+      it "raises error" do
+        expect { described_class.configure { |c| c.project_key = '1' } }.
+          to raise_error(Airbrake::Error, ':project_id is required')
+      end
+    end
+
+    context "when user config doesn't contain a project key" do
+      it "raises error" do
+        expect { described_class.configure { |c| c.project_id = 1 } }.
+          to raise_error(Airbrake::Error, ':project_key is required')
+      end
+    end
+  end
+
+  describe ".configured?" do
+    it "forwards 'configured?' to the notifier" do
+      expect(default_notifier).to receive(:configured?)
+      described_class.configured?
+    end
+  end
+
+  describe ".notify" do
+    it "forwards 'notify' to the notifier" do
+      block = proc {}
+      expect(default_notifier).to receive(:notify).with('ex', foo: 'bar', &block)
+      described_class.notify('ex', foo: 'bar', &block)
+    end
+  end
+
+  describe ".notify_sync" do
+    it "forwards 'notify_sync' to the notifier" do
+      block = proc {}
+      expect(default_notifier).to receive(:notify).with('ex', foo: 'bar', &block)
+      described_class.notify('ex', foo: 'bar', &block)
+    end
+  end
+
+  describe ".add_filter" do
+    it "forwards 'add_filter' to the notifier" do
+      block = proc {}
+      expect(default_notifier).to receive(:add_filter).with(nil, &block)
+      described_class.add_filter(&block)
+    end
+  end
+
+  describe ".build_notice" do
+    it "forwards 'build_notice' to the notifier" do
+      expect(default_notifier).to receive(:build_notice).with('ex', foo: 'bar')
+      described_class.build_notice('ex', foo: 'bar')
+    end
+  end
+
+  describe ".close" do
+    it "forwards 'close' to the notifier" do
+      expect(default_notifier).to receive(:close)
+      described_class.close
+    end
+  end
+
+  describe ".create_deploy" do
+    let(:default_notifier) { described_class.notifiers[:deploy][:default] }
+
+    it "calls 'notify' on the deploy notifier" do
+      expect(default_notifier).to receive(:notify).with(foo: 'bar')
+      described_class.create_deploy(foo: 'bar')
+    end
+  end
+
+  describe ".merge_context" do
+    it "forwards 'merge_context' to the notifier" do
+      expect(default_notifier).to receive(:merge_context).with(foo: 'bar')
+      described_class.merge_context(foo: 'bar')
+    end
+  end
+
+  describe ".notify_request" do
+    let(:default_notifier) { described_class.notifiers[:performance][:default] }
+
+    it "calls 'notify' on the route notifier" do
+      params = {
+        method: 'GET',
+        route: '/foo',
+        status_code: 200,
+        start_time: Time.new(2018, 1, 1, 0, 20, 0, 0),
+        end_time: Time.new(2018, 1, 1, 0, 19, 0, 0)
+      }
+      expect(default_notifier).to receive(:notify).with(Airbrake::Request.new(params))
+      described_class.notify_request(params)
+    end
+  end
+
+  describe ".notify_query" do
+    let(:default_notifier) { described_class.notifiers[:performance][:default] }
+
+    it "calls 'notify' on the query notifier" do
+      params = {
+        method: 'GET',
+        route: '/foo',
+        query: 'SELECT * FROM foos',
+        start_time: Time.new(2018, 1, 1, 0, 20, 0, 0),
+        end_time: Time.new(2018, 1, 1, 0, 19, 0, 0)
+      }
+      expect(default_notifier).to receive(:notify).with(Airbrake::Query.new(params))
+      described_class.notify_query(params)
+    end
+  end
+end

data/spec/async_sender_spec.rb

@@ -0,0 +1,154 @@
+RSpec.describe Airbrake::AsyncSender do
+  before do
+    stub_request(:post, /.*/).to_return(status: 201, body: '{}')
+  end
+
+  describe "#send" do
+    it "limits the size of the queue" do
+      stdout = StringIO.new
+      notices_count = 1000
+      queue_size = 10
+      config = Airbrake::Config.new(
+        logger: Logger.new(stdout), workers: 3, queue_size: queue_size
+      )
+      sender = described_class.new(config)
+      expect(sender).to have_workers
+
+      notice = Airbrake::Notice.new(config, AirbrakeTestError.new)
+      notices_count.times { sender.send(notice, Airbrake::Promise.new) }
+      sender.close
+
+      log = stdout.string.split("\n")
+      notices_sent    = log.grep(/\*\*Airbrake: Airbrake::Response \(201\): \{\}/).size
+      notices_dropped = log.grep(/\*\*Airbrake:.*not.*delivered/).size
+      expect(notices_sent).to be >= queue_size
+      expect(notices_sent + notices_dropped).to eq(notices_count)
+    end
+  end
+
+  describe "#close" do
+    before do
+      @stderr = StringIO.new
+      config = Airbrake::Config.new(logger: Logger.new(@stderr))
+      @sender = described_class.new(config)
+      expect(@sender).to have_workers
+    end
+
+    context "when there are no unsent notices" do
+      it "joins the spawned thread" do
+        workers = @sender.instance_variable_get(:@workers).list
+
+        expect(workers).to all(be_alive)
+        @sender.close
+        expect(workers).to all(be_stop)
+      end
+    end
+
+    context "when there are some unsent notices" do
+      before do
+        notice = Airbrake::Notice.new(Airbrake::Config.new, AirbrakeTestError.new)
+        300.times { @sender.send(notice, Airbrake::Promise.new) }
+        expect(@sender.instance_variable_get(:@unsent).size).not_to be_zero
+        @sender.close
+      end
+
+      it "warns about the number of notices" do
+        expect(@stderr.string).to match(/waiting to send \d+ unsent notice/)
+      end
+
+      it "prints the correct number of log messages" do
+        log = @stderr.string.split("\n")
+        notices_sent    = log.grep(/\*\*Airbrake: Airbrake::Response \(201\): \{\}/).size
+        notices_dropped = log.grep(/\*\*Airbrake:.*not.*delivered/).size
+        expect(notices_sent).to be >= @sender.instance_variable_get(:@unsent).max
+        expect(notices_sent + notices_dropped).to eq(300)
+      end
+
+      it "waits until the unsent notices queue is empty" do
+        expect(@sender.instance_variable_get(:@unsent).size).to be_zero
+      end
+    end
+
+    context "when it was already closed" do
+      it "doesn't increase the unsent queue size" do
+        begin
+          @sender.close
+        rescue Airbrake::Error
+          nil
+        end
+
+        expect(@sender.instance_variable_get(:@unsent).size).to be_zero
+      end
+
+      it "raises error" do
+        @sender.close
+
+        expect(@sender).to be_closed
+        expect { @sender.close }.
+          to raise_error(Airbrake::Error, 'attempted to close already closed sender')
+      end
+    end
+
+    context "when workers were not spawned" do
+      it "correctly closes the notifier nevertheless" do
+        sender = described_class.new(Airbrake::Config.new)
+        sender.close
+
+        expect(sender).to be_closed
+      end
+    end
+  end
+
+  describe "#has_workers?" do
+    before do
+      @sender = described_class.new(Airbrake::Config.new)
+      expect(@sender).to have_workers
+    end
+
+    it "returns false when the sender is not closed, but has 0 workers" do
+      @sender.instance_variable_get(:@workers).list.each(&:kill)
+      sleep 1
+      expect(@sender).not_to have_workers
+    end
+
+    it "returns false when the sender is closed" do
+      @sender.close
+      expect(@sender).not_to have_workers
+    end
+
+    it "respawns workers on fork()", skip: %w[jruby rbx].include?(RUBY_ENGINE) do
+      pid = fork do
+        expect(@sender).to have_workers
+      end
+      Process.wait(pid)
+      @sender.close
+      expect(@sender).not_to have_workers
+    end
+  end
+
+  describe "#spawn_workers" do
+    it "spawns alive threads in an enclosed ThreadGroup" do
+      sender = described_class.new(Airbrake::Config.new)
+      expect(sender).to have_workers
+
+      workers = sender.instance_variable_get(:@workers)
+
+      expect(workers).to be_a(ThreadGroup)
+      expect(workers.list).to all(be_alive)
+      expect(workers).to be_enclosed
+
+      sender.close
+    end
+
+    it "spawns exactly config.workers workers" do
+      workers_count = 5
+      sender = described_class.new(Airbrake::Config.new(workers: workers_count))
+      expect(sender).to have_workers
+
+      workers = sender.instance_variable_get(:@workers)
+
+      expect(workers.list.size).to eq(workers_count)
+      sender.close
+    end
+  end
+end

data/spec/backtrace_spec.rb

@@ -0,0 +1,438 @@
+RSpec.describe Airbrake::Backtrace do
+  let(:config) do
+    Airbrake::Config.new.tap { |c| c.logger = Logger.new('/dev/null') }
+  end
+
+  describe ".parse" do
+    context "UNIX backtrace" do
+      let(:parsed_backtrace) do
+        # rubocop:disable Metrics/LineLength, Style/HashSyntax, Layout/SpaceAroundOperators, Layout/SpaceInsideHashLiteralBraces
+        [{:file=>"/home/kyrylo/code/airbrake/ruby/spec/spec_helper.rb", :line=>23, :function=>"<top (required)>"},
+         {:file=>"/opt/rubies/ruby-2.2.2/lib/ruby/2.2.0/rubygems/core_ext/kernel_require.rb", :line=>54, :function=>"require"},
+         {:file=>"/opt/rubies/ruby-2.2.2/lib/ruby/2.2.0/rubygems/core_ext/kernel_require.rb", :line=>54, :function=>"require"},
+         {:file=>"/home/kyrylo/code/airbrake/ruby/spec/airbrake_spec.rb", :line=>1, :function=>"<top (required)>"},
+         {:file=>"/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/lib/rspec/core/configuration.rb", :line=>1327, :function=>"load"},
+         {:file=>"/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/lib/rspec/core/configuration.rb", :line=>1327, :function=>"block in load_spec_files"},
+         {:file=>"/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/lib/rspec/core/configuration.rb", :line=>1325, :function=>"each"},
+         {:file=>"/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/lib/rspec/core/configuration.rb", :line=>1325, :function=>"load_spec_files"},
+         {:file=>"/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/lib/rspec/core/runner.rb", :line=>102, :function=>"setup"},
+         {:file=>"/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/lib/rspec/core/runner.rb", :line=>88, :function=>"run"},
+         {:file=>"/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/lib/rspec/core/runner.rb", :line=>73, :function=>"run"},
+         {:file=>"/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/lib/rspec/core/runner.rb", :line=>41, :function=>"invoke"},
+         {:file=>"/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/exe/rspec", :line=>4, :function=>"<main>"}]
+        # rubocop:enable Metrics/LineLength, Style/HashSyntax, Layout/SpaceAroundOperators, Layout/SpaceInsideHashLiteralBraces
+      end
+
+      it "returns a properly formatted array of hashes" do
+        expect(
+          described_class.parse(config, AirbrakeTestError.new)
+        ).to eq(parsed_backtrace)
+      end
+    end
+
+    context "Windows backtrace" do
+      let(:windows_bt) do
+        ["C:/Program Files/Server/app/models/user.rb:13:in `magic'",
+         "C:/Program Files/Server/app/controllers/users_controller.rb:8:in `index'"]
+      end
+
+      let(:ex) { AirbrakeTestError.new.tap { |e| e.set_backtrace(windows_bt) } }
+
+      let(:parsed_backtrace) do
+        # rubocop:disable Metrics/LineLength, Style/HashSyntax, Layout/SpaceInsideHashLiteralBraces, Layout/SpaceAroundOperators
+        [{:file=>"C:/Program Files/Server/app/models/user.rb", :line=>13, :function=>"magic"},
+         {:file=>"C:/Program Files/Server/app/controllers/users_controller.rb", :line=>8, :function=>"index"}]
+        # rubocop:enable Metrics/LineLength, Style/HashSyntax, Layout/SpaceInsideHashLiteralBraces, Layout/SpaceAroundOperators
+      end
+
+      it "returns a properly formatted array of hashes" do
+        expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+      end
+    end
+
+    context "JRuby Java exceptions" do
+      let(:backtrace_array) do
+        # rubocop:disable Metrics/LineLength, Style/HashSyntax, Layout/SpaceInsideHashLiteralBraces, Layout/SpaceAroundOperators
+        [{:file=>"InstanceMethodInvoker.java", :line=>26, :function=>"org.jruby.java.invokers.InstanceMethodInvoker.call"},
+         {:file=>"Interpreter.java", :line=>126, :function=>"org.jruby.ir.interpreter.Interpreter.INTERPRET_EVAL"},
+         {:file=>"RubyKernel$INVOKER$s$0$3$eval19.gen", :line=>nil, :function=>"org.jruby.RubyKernel$INVOKER$s$0$3$eval19.call"},
+         {:file=>"RubyKernel$INVOKER$s$0$0$loop.gen", :line=>nil, :function=>"org.jruby.RubyKernel$INVOKER$s$0$0$loop.call"},
+         {:file=>"IRBlockBody.java", :line=>139, :function=>"org.jruby.runtime.IRBlockBody.doYield"},
+         {:file=>"RubyKernel$INVOKER$s$rbCatch19.gen", :line=>nil, :function=>"org.jruby.RubyKernel$INVOKER$s$rbCatch19.call"},
+         {:file=>"/opt/rubies/jruby-9.0.0.0/bin/irb", :line=>nil, :function=>"opt.rubies.jruby_minus_9_dot_0_dot_0_dot_0.bin.irb.invokeOther4:start"},
+         {:file=>"/opt/rubies/jruby-9.0.0.0/bin/irb", :line=>13, :function=>"opt.rubies.jruby_minus_9_dot_0_dot_0_dot_0.bin.irb.RUBY$script"},
+         {:file=>"Compiler.java", :line=>111, :function=>"org.jruby.ir.Compiler$1.load"},
+         {:file=>"Main.java", :line=>225, :function=>"org.jruby.Main.run"},
+         {:file=>"Main.java", :line=>197, :function=>"org.jruby.Main.main"}]
+        # rubocop:enable Metrics/LineLength, Style/HashSyntax, Layout/SpaceInsideHashLiteralBraces, Layout/SpaceAroundOperators
+      end
+
+      it "returns a properly formatted array of hashes" do
+        allow(described_class).to receive(:java_exception?).and_return(true)
+
+        expect(
+          described_class.parse(config, JavaAirbrakeTestError.new)
+        ).to eq(backtrace_array)
+      end
+    end
+
+    context "JRuby classloader exceptions" do
+      let(:backtrace) do
+        # rubocop:disable Metrics/LineLength
+        ['uri_3a_classloader_3a_.META_minus_INF.jruby_dot_home.lib.ruby.stdlib.net.protocol.rbuf_fill(uri:classloader:/META-INF/jruby.home/lib/ruby/stdlib/net/protocol.rb:158)',
+         'bin.processors.image_uploader.block in make_streams(bin/processors/image_uploader.rb:21)',
+         'uri_3a_classloader_3a_.gems.faye_minus_websocket_minus_0_dot_10_dot_5.lib.faye.websocket.api.invokeOther13:dispatch_event(uri_3a_classloader_3a_/gems/faye_minus_websocket_minus_0_dot_10_dot_5/lib/faye/websocket/uri:classloader:/gems/faye-websocket-0.10.5/lib/faye/websocket/api.rb:109)',
+         'tmp.jruby9022301782566983632extract.$dot.META_minus_INF.rails.file(/tmp/jruby9022301782566983632extract/./META-INF/rails.rb:13)']
+        # rubocop:enable Metrics/LineLength
+      end
+
+      let(:parsed_backtrace) do
+        # rubocop:disable Metrics/LineLength
+        [{ file: 'uri:classloader:/META-INF/jruby.home/lib/ruby/stdlib/net/protocol.rb', line: 158, function: 'uri_3a_classloader_3a_.META_minus_INF.jruby_dot_home.lib.ruby.stdlib.net.protocol.rbuf_fill' },
+         { file: 'bin/processors/image_uploader.rb', line: 21, function: 'bin.processors.image_uploader.block in make_streams' },
+         { file: 'uri_3a_classloader_3a_/gems/faye_minus_websocket_minus_0_dot_10_dot_5/lib/faye/websocket/uri:classloader:/gems/faye-websocket-0.10.5/lib/faye/websocket/api.rb', line: 109, function: 'uri_3a_classloader_3a_.gems.faye_minus_websocket_minus_0_dot_10_dot_5.lib.faye.websocket.api.invokeOther13:dispatch_event' },
+         { file: '/tmp/jruby9022301782566983632extract/./META-INF/rails.rb', line: 13, function: 'tmp.jruby9022301782566983632extract.$dot.META_minus_INF.rails.file' }]
+        # rubocop:enable Metrics/LineLength
+      end
+
+      let(:ex) { JavaAirbrakeTestError.new.tap { |e| e.set_backtrace(backtrace) } }
+
+      it "returns a properly formatted array of hashes" do
+        allow(described_class).to receive(:java_exception?).and_return(true)
+        expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+      end
+    end
+
+    context "JRuby non-throwable exceptions" do
+      let(:backtrace) do
+        # rubocop:disable Metrics/LineLength
+        ['org.postgresql.core.v3.ConnectionFactoryImpl.openConnectionImpl(org/postgresql/core/v3/ConnectionFactoryImpl.java:257)',
+         'org.postgresql.core.ConnectionFactory.openConnection(org/postgresql/core/ConnectionFactory.java:65)',
+         'org.postgresql.jdbc2.AbstractJdbc2Connection.<init>(org/postgresql/jdbc2/AbstractJdbc2Connection.java:149)']
+        # rubocop:enable Metrics/LineLength
+      end
+
+      let(:parsed_backtrace) do
+        # rubocop:disable Metrics/LineLength
+        [{ file: 'org/postgresql/core/v3/ConnectionFactoryImpl.java', line: 257, function: 'org.postgresql.core.v3.ConnectionFactoryImpl.openConnectionImpl' },
+         { file: 'org/postgresql/core/ConnectionFactory.java', line: 65, function: 'org.postgresql.core.ConnectionFactory.openConnection' },
+         { file: 'org/postgresql/jdbc2/AbstractJdbc2Connection.java', line: 149, function: 'org.postgresql.jdbc2.AbstractJdbc2Connection.<init>' }]
+        # rubocop:enable Metrics/LineLength
+      end
+
+      let(:ex) { AirbrakeTestError.new.tap { |e| e.set_backtrace(backtrace) } }
+
+      it "returns a properly formatted array of hashes" do
+        expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+      end
+    end
+
+    context "generic backtrace" do
+      context "when function is absent" do
+        # rubocop:disable Metrics/LineLength
+        let(:generic_bt) do
+          ["/home/bingo/bango/assets/stylesheets/error_pages.scss:139:in `animation'",
+           "/home/bingo/bango/assets/stylesheets/error_pages.scss:139",
+           "/home/bingo/.gem/ruby/2.2.2/gems/sass-3.4.20/lib/sass/tree/visitors/perform.rb:349:in `block in visit_mixin'"]
+        end
+        # rubocop:enable Metrics/LineLength
+
+        let(:ex) { AirbrakeTestError.new.tap { |e| e.set_backtrace(generic_bt) } }
+
+        let(:parsed_backtrace) do
+          # rubocop:disable Metrics/LineLength, Style/HashSyntax, Layout/SpaceInsideHashLiteralBraces, Layout/SpaceAroundOperators
+          [{:file=>"/home/bingo/bango/assets/stylesheets/error_pages.scss", :line=>139, :function=>"animation"},
+           {:file=>"/home/bingo/bango/assets/stylesheets/error_pages.scss", :line=>139, :function=>nil},
+           {:file=>"/home/bingo/.gem/ruby/2.2.2/gems/sass-3.4.20/lib/sass/tree/visitors/perform.rb", :line=>349, :function=>"block in visit_mixin"}]
+          # rubocop:enable Metrics/LineLength, Style/HashSyntax, Layout/SpaceInsideHashLiteralBraces, Layout/SpaceAroundOperators
+        end
+
+        it "returns a properly formatted array of hashes" do
+          expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+        end
+      end
+
+      context "when line is absent" do
+        let(:generic_bt) do
+          ["/Users/grammakov/repositories/weintervene/config.ru:in `new'"]
+        end
+
+        let(:ex) { AirbrakeTestError.new.tap { |e| e.set_backtrace(generic_bt) } }
+
+        let(:parsed_backtrace) do
+          [{ file: '/Users/grammakov/repositories/weintervene/config.ru',
+             line: nil,
+             function: 'new' }]
+        end
+
+        it "returns a properly formatted array of hashes" do
+          expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+        end
+      end
+    end
+
+    context "unknown backtrace" do
+      let(:unknown_bt) { ['a b c 1 23 321 .rb'] }
+
+      let(:ex) { AirbrakeTestError.new.tap { |e| e.set_backtrace(unknown_bt) } }
+
+      it "returns array of hashes where each unknown frame is marked as 'function'" do
+        expect(
+          described_class.parse(config, ex)
+        ).to eq([file: nil, line: nil, function: 'a b c 1 23 321 .rb'])
+      end
+
+      it "logs unknown frames as errors" do
+        out = StringIO.new
+        config.logger = Logger.new(out)
+
+        expect { described_class.parse(config, ex) }.
+          to change { out.string }.
+          from('').
+          to(/ERROR -- : can't parse 'a b c 1 23 321 .rb'/)
+      end
+    end
+
+    context "given a backtrace with an empty function" do
+      let(:bt) do
+        ["/airbrake-ruby/vendor/jruby/1.9/gems/rspec-core-3.4.1/exe/rspec:3:in `'"]
+      end
+
+      let(:ex) { AirbrakeTestError.new.tap { |e| e.set_backtrace(bt) } }
+
+      let(:parsed_backtrace) do
+        [{ file: '/airbrake-ruby/vendor/jruby/1.9/gems/rspec-core-3.4.1/exe/rspec',
+           line: 3,
+           function: '' }]
+      end
+
+      it "returns a properly formatted array of hashes" do
+        expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+      end
+    end
+
+    context "given an Oracle backtrace" do
+      let(:bt) do
+        ['ORA-06512: at "STORE.LI_LICENSES_PACK", line 1945',
+         'ORA-06512: at "ACTIVATION.LI_ACT_LICENSES_PACK", line 101',
+         'ORA-06512: at line 2',
+         'from stmt.c:243:in oci8lib_220.bundle']
+      end
+
+      let(:ex) { OCIError.new.tap { |e| e.set_backtrace(bt) } }
+
+      let(:parsed_backtrace) do
+        [{ file: nil, line: 1945, function: 'STORE.LI_LICENSES_PACK' },
+         { file: nil, line: 101, function: 'ACTIVATION.LI_ACT_LICENSES_PACK' },
+         { file: nil, line: 2, function: nil },
+         { file: 'stmt.c', line: 243, function: 'oci8lib_220.bundle' }]
+      end
+
+      it "returns a properly formatted array of hashes" do
+        stub_const('OCIError', AirbrakeTestError)
+        expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+      end
+    end
+
+    context "given an ExecJS exception" do
+      let(:bt) do
+        ['compile ((execjs):6692:19)',
+         'eval (<anonymous>:1:10)',
+         '(execjs):6703:8',
+         'require../helpers.exports ((execjs):1:102)',
+         'Object.<anonymous> ((execjs):1:120)',
+         'Object.Module._extensions..js (module.js:550:10)',
+         'bootstrap_node.js:467:3',
+         "/opt/rubies/ruby-2.3.1/lib/ruby/2.3.0/benchmark.rb:308:in `realtime'"]
+      end
+
+      let(:ex) { ExecJS::RuntimeError.new.tap { |e| e.set_backtrace(bt) } }
+
+      let(:parsed_backtrace) do
+        [{ file: '(execjs)', line: 6692, function: 'compile' },
+         { file: '<anonymous>', line: 1, function: 'eval' },
+         { file: '(execjs)', line: 6703, function: '' },
+         { file: '(execjs)', line: 1, function: 'require../helpers.exports' },
+         { file: '(execjs)', line: 1, function: 'Object.<anonymous>' },
+         { file: 'module.js', line: 550, function: 'Object.Module._extensions..js' },
+         { file: 'bootstrap_node.js', line: 467, function: '' },
+         { file: '/opt/rubies/ruby-2.3.1/lib/ruby/2.3.0/benchmark.rb',
+           line: 308,
+           function: 'realtime' }]
+      end
+
+      it "returns a properly formatted array of hashes" do
+        stub_const('ExecJS::RuntimeError', AirbrakeTestError)
+        expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+      end
+    end
+
+    context "when code hunks are enabled" do
+      let(:config) do
+        config = Airbrake::Config.new
+        config.logger = Logger.new('/dev/null')
+        config.code_hunks = true
+        config
+      end
+
+      context "and when root_directory is configured" do
+        before { config.root_directory = project_root_path('') }
+
+        let(:parsed_backtrace) do
+          [
+            {
+              file: project_root_path('code.rb'),
+              line: 94,
+              function: 'to_json',
+              code: {
+                92 => '      loop do',
+                93 => '        begin',
+                94 => '          json = @payload.to_json',
+                95 => '        rescue *JSON_EXCEPTIONS => ex',
+                # rubocop:disable Metrics/LineLength,Lint/InterpolationCheck
+                96 => '          @config.logger.debug("#{LOG_LABEL} `notice.to_json` failed: #{ex.class}: #{ex}")',
+                # rubocop:enable Metrics/LineLength,Lint/InterpolationCheck
+              }
+            },
+            {
+              file: fixture_path('notroot.txt'),
+              line: 3,
+              function: 'pineapple'
+            },
+            {
+              file: project_root_path('vendor/bundle/ignored_file.rb'),
+              line: 2,
+              function: 'ignore_me'
+            }
+          ]
+        end
+
+        it "attaches code to those frames files of which match root_directory" do
+          ex = RuntimeError.new
+          backtrace = [
+            project_root_path('code.rb') + ":94:in `to_json'",
+            fixture_path('notroot.txt' + ":3:in `pineapple'"),
+            project_root_path('vendor/bundle/ignored_file.rb') + ":2:in `ignore_me'"
+          ]
+          ex.set_backtrace(backtrace)
+          expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+        end
+      end
+
+      context "and when root_directory is a Pathname" do
+        before { config.root_directory = Pathname.new(project_root_path('')) }
+
+        let(:parsed_backtrace) do
+          [
+            {
+              file: project_root_path('code.rb'),
+              line: 94,
+              function: 'to_json',
+              code: {
+                92 => '      loop do',
+                93 => '        begin',
+                94 => '          json = @payload.to_json',
+                95 => '        rescue *JSON_EXCEPTIONS => ex',
+                # rubocop:disable Metrics/LineLength,Lint/InterpolationCheck
+                96 => '          @config.logger.debug("#{LOG_LABEL} `notice.to_json` failed: #{ex.class}: #{ex}")',
+                # rubocop:enable Metrics/LineLength,Lint/InterpolationCheck
+              }
+            }
+          ]
+        end
+
+        it "attaches code to those frames files of which match root_directory" do
+          ex = RuntimeError.new
+          ex.set_backtrace([project_root_path('code.rb') + ":94:in `to_json'"])
+          expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+        end
+      end
+
+      context "and when root_directory isn't configured" do
+        before do
+          config.root_directory = nil
+          stub_const('Airbrake::Backtrace::CODE_FRAME_LIMIT', 2)
+        end
+
+        let(:parsed_backtrace) do
+          [
+            {
+              file: project_root_path('code.rb'),
+              line: 94,
+              function: 'to_json',
+              code: {
+                92 => '      loop do',
+                93 => '        begin',
+                94 => '          json = @payload.to_json',
+                95 => '        rescue *JSON_EXCEPTIONS => ex',
+                # rubocop:disable Metrics/LineLength,Lint/InterpolationCheck
+                96 => '          @config.logger.debug("#{LOG_LABEL} `notice.to_json` failed: #{ex.class}: #{ex}")',
+                # rubocop:enable Metrics/LineLength,Lint/InterpolationCheck
+              }
+            },
+            {
+              file: project_root_path('code.rb'),
+              line: 95,
+              function: 'to_json',
+              code: {
+                93 => '        begin',
+                94 => '          json = @payload.to_json',
+                95 => '        rescue *JSON_EXCEPTIONS => ex',
+                # rubocop:disable Metrics/LineLength,Lint/InterpolationCheck
+                96 => '          @config.logger.debug("#{LOG_LABEL} `notice.to_json` failed: #{ex.class}: #{ex}")',
+                # rubocop:enable Metrics/LineLength,Lint/InterpolationCheck
+                97 => '        else'
+              }
+            },
+            {
+              file: project_root_path('code.rb'),
+              line: 96,
+              function: 'to_json'
+            }
+          ]
+        end
+
+        it "attaches code to first N frames" do
+          ex = RuntimeError.new
+          backtrace = [
+            project_root_path('code.rb') + ":94:in `to_json'",
+            project_root_path('code.rb') + ":95:in `to_json'",
+            project_root_path('code.rb') + ":96:in `to_json'"
+          ]
+          ex.set_backtrace(backtrace)
+          expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+        end
+      end
+    end
+
+    context "when code hunks are disabled" do
+      let(:config) do
+        config = Airbrake::Config.new
+        config.logger = Logger.new('/dev/null')
+        config.code_hunks = false
+        config
+      end
+
+      context "and when root_directory is configured" do
+        before { config.root_directory = project_root_path('') }
+
+        let(:parsed_backtrace) do
+          [
+            {
+              file: project_root_path('code.rb'),
+              line: 94,
+              function: 'to_json'
+            }
+          ]
+        end
+
+        it "doesn't attach code to frames" do
+          ex = RuntimeError.new
+          backtrace = [project_root_path('code.rb') + ":94:in `to_json'"]
+          ex.set_backtrace(backtrace)
+          expect(described_class.parse(config, ex)).to eq(parsed_backtrace)
+        end
+      end
+    end
+  end
+end