bugsnag 6.15.0 → 6.27.1

data/spec/fixtures/middleware/internal_info_setter.rb

@@ -1,11 +0,0 @@
-class InternalInfoSetter
-  MESSAGE = "set by internal_middleware"
-  def initialize(bugsnag)
-    @bugsnag = bugsnag
-  end
-
-  def call(report)
-    report.meta_data.merge!({custom: {info: MESSAGE}})
-    @bugsnag.call(report)
-  end
-end

data/spec/fixtures/middleware/public_info_setter.rb

@@ -1,11 +0,0 @@
-class PublicInfoSetter
-  MESSAGE = "set by middleware"
-  def initialize(bugsnag)
-    @bugsnag = bugsnag
-  end
-
-  def call(report)
-    report.meta_data.merge!({custom: {info: MESSAGE}})
-    @bugsnag.call(report)
-  end
-end

data/spec/fixtures/tasks/Rakefile

@@ -1,26 +0,0 @@
-if Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2.0')
-  # Mixing Module#prepend with alias_method can sometimes lead to infinite
-  # mutual recursion, so this is to test that it doesn't happen.
-  mod = Module.new do
-    def execute(args = nil)
-      puts 'In module prepended to Rake::Task'
-      super
-    end
-  end
-  Rake::Task.send(:prepend, mod)
-end
-
-require "bugsnag/integrations/rake"
-
-namespace :test do
-  desc "used by integration_spec to test that Bugsnag::Middleware::Rake runs properly"
-  task :crash do
-    port = ENV['BUGSNAG_TEST_SERVER_PORT']
-    Bugsnag.configure do |config|
-      config.endpoint = "http://localhost:#{port}"
-      config.api_key = "0" * 32
-    end
-
-    raise
-  end
-end

data/spec/helper_spec.rb

@@ -1,131 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'set'
-
-describe Bugsnag::Helpers do
-  describe "trim_if_needed" do
-    it "preserves bool types" do
-      value = Bugsnag::Helpers.trim_if_needed([1, 3, true, "NO", "2", false])
-      expect(value[2]).to be_a(TrueClass)
-      expect(value[5]).to be_a(FalseClass)
-    end
-
-    it "preserves Numeric types" do
-      value = Bugsnag::Helpers.trim_if_needed([1, 3.445, true, "NO", "2", false])
-      expect(value[0]).to be_a(Numeric)
-      expect(value[1]).to be_a(Numeric)
-    end
-
-    it "preserves String types" do
-      value = Bugsnag::Helpers.trim_if_needed([1, 3, true, "NO", "2", false])
-      expect(value[3]).to be_a(String)
-      expect(value[4]).to be_a(String)
-    end
-
-    context "payload length is less than allowed" do
-      it "does not change strings" do
-        value = SecureRandom.hex(4096)
-        expect(Bugsnag::Helpers.trim_if_needed(value)).to eq value
-      end
-
-      it "does not change arrays" do
-        value = 1000.times.map {|i| "#{i} - #{i + 1}" }
-        expect(Bugsnag::Helpers.trim_if_needed(value)).to eq value
-      end
-
-      it "does not change hashes" do
-        value = Hash[*1000.times.map{|i| ["#{i}", i]}.flatten]
-        expect(Bugsnag::Helpers.trim_if_needed(value)).to eq value
-      end
-    end
-
-    context "payload length is greater than allowed" do
-      it "trims metadata strings" do
-        payload = {
-          :events => [{
-            :metaData => 50000.times.map {|i| "should truncate" }.join(""),
-            :preserved => "Foo"
-          }]
-        }
-        expect(::JSON.dump(payload).length).to be > Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
-        trimmed = Bugsnag::Helpers.trim_if_needed(payload)
-        expect(::JSON.dump(trimmed).length).to be <= Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
-        expect(trimmed[:events][0][:metaData].length).to be <= Bugsnag::Helpers::MAX_STRING_LENGTH
-        expect(trimmed[:events][0][:preserved]).to eq("Foo")
-      end
-
-      it "truncates metadata arrays" do
-        payload = {
-          :events => [{
-            :metaData => 50000.times.map {|i| "should truncate" },
-            :preserved => "Foo"
-          }]
-        }
-        expect(::JSON.dump(payload).length).to be > Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
-        trimmed = Bugsnag::Helpers.trim_if_needed(payload)
-        expect(::JSON.dump(trimmed).length).to be <= Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
-        expect(trimmed[:events][0][:metaData].length).to be <= Bugsnag::Helpers::MAX_ARRAY_LENGTH
-        expect(trimmed[:events][0][:preserved]).to eq("Foo")
-      end
-
-      it "trims stacktrace code" do
-        payload = {
-          :events => [{
-            :exceptions => [{
-              :stacktrace => [
-                {
-                  :lineNumber => 1,
-                  :file => '/trace1',
-                  :code => 50.times.map {|i| SecureRandom.hex(3072) }
-                },
-                {
-                  :lineNumber => 2,
-                  :file => '/trace2',
-                  :code => 50.times.map {|i| SecureRandom.hex(3072) }
-                }
-              ]
-            }]
-          }]
-        }
-        expect(::JSON.dump(payload).length).to be > Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
-        trimmed = Bugsnag::Helpers.trim_if_needed(payload)
-        expect(::JSON.dump(trimmed).length).to be <= Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
-        trace = trimmed[:events][0][:exceptions][0][:stacktrace]
-        expect(trace.length).to eq(2)
-        expect(trace[0][:lineNumber]).to eq(1)
-        expect(trace[0][:file]).to eq('/trace1')
-        expect(trace[0][:code]).to be_nil
-        expect(trace[1][:lineNumber]).to eq(2)
-        expect(trace[1][:file]).to eq('/trace2')
-        expect(trace[1][:code]).to be_nil
-      end
-
-      it "trims stacktrace entries" do
-        payload = {
-          :events => [{
-            :exceptions => [{
-              :stacktrace => 18000.times.map do |index|
-                {
-                  :lineNumber => index,
-                  :file => "/path/to/item_#{index}.rb",
-                  :code => { "#{index}" => "puts 'code'" }
-                }
-              end
-            }]
-          }]
-        }
-        expect(::JSON.dump(payload).length).to be > Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
-        trimmed = Bugsnag::Helpers.trim_if_needed(payload)
-        expect(::JSON.dump(trimmed).length).to be <= Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
-        trace = trimmed[:events][0][:exceptions][0][:stacktrace]
-        expect(trace.length).to eq(30)
-        30.times.map do |index|
-          expect(trace[index][:lineNumber]).to eq(index)
-          expect(trace[index][:file]).to eq("/path/to/item_#{index}.rb")
-          expect(trace[index][:code]).to be_nil
-        end
-      end
-    end
-  end
-end

data/spec/integration_spec.rb

@@ -1,107 +0,0 @@
-require 'webrick'
-require 'spec_helper'
-require 'json'
-
-describe 'Bugsnag' do
-  server = nil
-  queue = Queue.new
-
-  before do
-    server = WEBrick::HTTPServer.new :Port => 0, :Logger => WEBrick::Log.new("/dev/null"), :AccessLog => []
-    server.mount_proc '/' do |req, res|
-      queue.push req.body
-      res.status = 200
-      res.body = "OK\n"
-    end
-    Thread.new{ server.start }
-  end
-
-  after do
-    server.stop
-    queue.clear
-  end
-
-  let(:request) { JSON.parse(queue.pop) }
-
-  it 'should send notifications over the wire' do
-    Bugsnag.configure do |config|
-      config.endpoint = "http://localhost:#{server.config[:Port]}"
-    end
-    WebMock.allow_net_connect!
-
-    Bugsnag.notify 'yo'
-
-    expect(request['events'][0]['exceptions'][0]['message']).to eq('yo')
-  end
-
-  it 'should work with threadpool delivery' do
-    Bugsnag.configure do |config|
-      config.endpoint = "http://localhost:#{server.config[:Port]}"
-      config.delivery_method = :thread_queue
-    end
-    WebMock.allow_net_connect!
-
-    Bugsnag.notify 'yo'
-
-    expect(request['events'][0]['exceptions'][0]['message']).to eq('yo')
-  end
-
-  it 'should work with threadpool delivery after fork' do
-    is_jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-    unless is_jruby #jruby doesn't support fork, so this test doesn't apply
-      Bugsnag.configure do |config|
-        config.endpoint = "http://localhost:#{server.config[:Port]}"
-        config.delivery_method = :thread_queue
-      end
-      WebMock.allow_net_connect!
-
-      Bugsnag.notify 'yo'
-
-      pid = Process.fork do
-        Bugsnag.notify 'yo too'
-      end
-      Process.wait(pid)
-
-      expect(queue.length).to eq(2)
-    end
-  end
-
-  describe 'with a proxy' do
-    proxy = nil
-    pqueue = Queue.new
-
-    before do
-      proxy = WEBrick::HTTPServer.new :Port => 0, :Logger => WEBrick::Log.new("/dev/null"), :AccessLog => []
-      proxy.mount_proc '/' do |req, res|
-        pqueue.push req
-        res.status = 200
-        res.body = "OK\n"
-      end
-      Thread.new{ proxy.start }
-    end
-    after do
-      proxy.stop
-    end
-
-    let(:proxied_request) { pqueue.pop }
-
-    it 'should use a proxy when configured' do
-      Bugsnag.configure do |config|
-
-        config.endpoint = "http://localhost:#{server.config[:Port]}"
-
-        config.proxy_host = 'localhost'
-        config.proxy_port = proxy.config[:Port]
-        config.proxy_user = 'conrad'
-        config.proxy_password = '$ecret'
-      end
-
-      Bugsnag.notify 'oy'
-
-      r = proxied_request
-
-      expect(r.header['proxy-authorization'].first).to eq("Basic Y29ucmFkOiRlY3JldA==")
-      expect(r.request_line).to eq("POST http://localhost:#{server.config[:Port]}/ HTTP/1.1\r\n")
-    end
-  end
-end

data/spec/integrations/clearance_user_spec.rb

@@ -1,38 +0,0 @@
-require "spec_helper"
-
-describe Bugsnag::Middleware::ClearanceUser do
-  it "updates the reports user with warden parameters" do
-    callback = double
-
-    user = double
-    allow(user).to receive_messages(
-      :email => "TEST_EMAIL",
-      :name => "TEST_NAME",
-      :created_at => "TEST_NOW"
-    )
-
-    clearance = double
-    allow(clearance).to receive_messages(
-      :signed_in? => true,
-      :current_user => user
-    )
-
-    report = double("Bugsnag::Report") 
-    expect(report).to receive(:request_data).exactly(5).times.and_return({
-      :rack_env => {
-        :clearance => clearance
-      }
-    })
-
-    expect(report).to receive(:user=).with({
-      :email => "TEST_EMAIL",
-      :name => "TEST_NAME",
-      :created_at => "TEST_NOW"
-    })
-
-    expect(callback).to receive(:call).with(report)
-
-    middleware = Bugsnag::Middleware::ClearanceUser.new(callback)
-    middleware.call(report)
-  end
-end

data/spec/integrations/logger_spec.rb

@@ -1,134 +0,0 @@
-require 'spec_helper'
-
-describe 'Configuration.logger' do
-
-  before do
-    @env = {}
-  end
-
-  context 'in a Rails app' do
-    key_warning = '[Bugsnag]: No valid API key has been set, notifications will not be sent'
-    is_jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-    incompatible = (RUBY_VERSION < '2.0.0') || is_jruby
-
-    before do
-      skip "Incompatible with Ruby <2.0 and JRuby" if incompatible
-      @env['RACK_ENV'] = 'production'
-    end
-
-    def run_app(name)
-      out_reader, out_writer = IO.pipe
-      Dir.chdir(File.join(File.dirname(__FILE__), "../fixtures/apps/#{name}")) do
-        Bundler.with_clean_env do
-          pid = Process.spawn('bundle install',
-                              out: out_writer.fileno,
-                              err: out_writer.fileno)
-          Process.waitpid(pid, 0)
-          pid = Process.spawn(@env, 'bundle exec rackup config.ru',
-                              out: out_writer.fileno,
-                              err: out_writer.fileno)
-          sleep(2)
-          Process.kill(1, pid)
-        end
-      end
-      out_writer.close
-      output = ""
-      output << out_reader.gets until out_reader.eof?
-      output
-    end
-    context 'sets an API key using the BUGSNAG_API_KEY env var' do
-      it 'does not log a warning' do
-        skip "Incompatible with Ruby <2.0 and JRuby" if incompatible
-        @env['BUGSNAG_API_KEY'] = 'c34a2472bd240ac0ab0f52715bbdc05d'
-        output = run_app('rails-no-config')
-        expect(output).not_to include(key_warning)
-      end
-    end
-
-    context 'sets an API key using the bugsnag initializer' do
-      it 'does not log a warning' do
-        skip "Incompatible with Ruby <2.0 and JRuby" if incompatible
-        output = run_app('rails-initializer-config')
-        expect(output).not_to include(key_warning)
-      end
-    end
-
-    context 'skips setting an API key' do
-      it 'logs a warning' do
-        skip "Incompatible with Ruby <2.0 and JRuby" if incompatible
-        output = run_app('rails-no-config')
-        expect(output).to include(key_warning)
-      end
-    end
-
-    context 'when the API key is invalid in the bugsnag initializer' do
-      it 'logs a warning' do
-        skip "Incompatible with Ruby <2.0 and JRuby" if incompatible
-        output = run_app('rails-invalid-initializer-config')
-        expect(output).to include(key_warning)
-      end
-    end
-
-    context 'sets an invalid API key using the BUGSNAG_API_KEY env var' do
-      it 'logs a warning' do
-        skip "Incompatible with Ruby <2.0 and JRuby" if incompatible
-        @env['BUGSNAG_API_KEY'] = 'not a real key'
-        output = run_app('rails-no-config')
-        expect(output).to include(key_warning)
-      end
-    end
-  end
-
-  context 'in a script' do
-    key_warning = /\[Bugsnag\] .* No valid API key has been set, notifications will not be sent/
-
-    def run_app(name)
-      output = ''
-      Dir.chdir(File.join(File.dirname(__FILE__), "../fixtures/apps/scripts")) do
-        Bundler.with_clean_env do
-          IO.popen([@env, 'bundle', 'exec', 'ruby', "#{name}.rb", err: [:child, :out]]) do |io|
-            output << io.read
-          end
-        end
-      end
-      output
-    end
-
-    context 'sets an API key using the BUGSNAG_API_KEY env var' do
-      it 'does not log a warning' do
-        @env['BUGSNAG_API_KEY'] = 'c34a2472bd240ac0ab0f52715bbdc05d'
-        output = run_app('no_config')
-        expect(output).not_to match(key_warning)
-      end
-    end
-
-    context 'sets an API key using Bugsnag.configure' do
-      it 'does not log a warning' do
-        output = run_app('configure_key')
-        expect(output).not_to match(key_warning)
-      end
-    end
-
-    context 'sets an invalid API key using Bugsnag.configure' do
-      it 'logs a warning' do
-        output = run_app('configure_invalid_key')
-        expect(output).to match(key_warning)
-      end
-    end
-
-    context 'sets an invalid API key using the BUGSNAG_API_KEY env var' do
-      it 'logs a warning' do
-        @env['BUGSNAG_API_KEY'] = 'bad key bad key whatcha gonna do'
-        output = run_app('no_config')
-        expect(output).to match(key_warning)
-      end
-    end
-
-    context 'skips setting an API key' do
-      it 'logs a warning' do
-        output = run_app('no_config')
-        expect(output).to match(key_warning)
-      end
-    end
-  end
-end

data/spec/integrations/mailman_spec.rb

@@ -1,83 +0,0 @@
-require "spec_helper"
-
-describe 'Bugsnag::Mailman', :order => :defined do
-  before do
-    unless defined?(::Mailman)
-      @mocked_mailman = true
-      class Mailman
-      end
-      module Kernel
-        alias_method :old_require, :require
-        def require(path)
-          old_require(path) unless /^mailman/.match(path)
-        end
-      end
-    end
-  end
-
-  it "should load Bugsnag::Mailman" do
-    config = double('mailman-config')
-    allow(Mailman).to receive(:config).and_return(config)
-    expect(config).to receive(:respond_to?).with(:middleware).and_return(true)
-    middleware = double('mailman-config-middleware')
-    expect(config).to receive(:middleware).and_return(middleware)
-    expect(middleware).to receive(:add).with(any_args)
-
-    #Kick off
-    require './lib/bugsnag/integrations/mailman'
-  end
-
-  it "can be called" do
-    config = double('config')
-    allow(Bugsnag).to receive(:configuration).and_return(config)
-    int_middleware = double('internal_middleware')
-    expect(config).to receive(:internal_middleware).and_return(int_middleware)
-    expect(int_middleware).to receive(:use).with(Bugsnag::Middleware::Mailman)
-    expect(config).to receive(:app_type=).with("mailman")
-
-    integration = Bugsnag::Mailman.new
-
-    mail = double('mail')
-    expect(config).to receive(:set_request_data).with(:mailman_msg, mail)
-    expect(mail).to receive(:to_s).and_return(mail)
-    allow(config).to receive(:clear_request_data)
-
-    exception = RuntimeError.new('oops')
-    report = double('report')
-    expect(Bugsnag).to receive(:notify).with(exception, true).and_yield(report)
-    expect(report).to receive(:severity=).with('error')
-    expect(report).to receive(:severity_reason=).with({
-      :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
-      :attributes => Bugsnag::Mailman::FRAMEWORK_ATTRIBUTES
-    })
-    expect{integration.call(mail) {raise exception}}.to raise_error(exception)
-  end
-
-  after do
-    Object.send(:remove_const, :Mailman) if @mocked_mailman
-    module Kernel
-      alias_method :require, :old_require
-    end
-  end
-end
-
-
-describe Bugsnag::Middleware::Mailman do
-  it "adds mailman message to the metadata" do
-    callback = double
-
-    report = double("Bugsnag::Report")
-    expect(report).to receive(:request_data).and_return({
-      :mailman_msg => "test message"
-    })
-
-    expect(report).to receive(:add_tab).with(:mailman, {
-      "message" => "test message"
-    })
-
-    expect(callback).to receive(:call).with(report)
-
-    middleware = Bugsnag::Middleware::Mailman.new(callback)
-    middleware.call(report)
-  end
-end