bugsnag 6.13.1 → 6.18.0

data/spec/integrations/que_spec.rb

@@ -1,94 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe 'Bugsnag::Que', :order => :defined do
-  before do
-    unless defined?(::Que)
-      @mocked_que = true
-      class ::Que
-        Version = '9.9.9'
-        class << self
-          attr_accessor :error_notifier
-        end
-      end
-      module Kernel
-        alias_method :old_require, :require
-        def require(path)
-          old_require(path) unless /^que/.match(path)
-        end
-      end
-    end
-  end
-
-  it "should create and register a que handler" do
-    error = RuntimeError.new("oops")
-    job = double('que_job')
-    expect(job).to receive(:dup).and_return({
-      :error_count => 0,
-      :job_class => 'ActiveJob::QueueAdapters::QueAdapter::JobWrapper',
-      :args => [{"queue_name" => "foo", "arguments" => "bar"}],
-      :job_id => "ID"
-    })
-
-    report = double('report')
-    expect(Bugsnag).to receive(:notify).with(error, true).and_yield(report)
-    expect(report).to receive(:add_tab).with(:job, {
-      :error_count => 1,
-      :job_class => 'ActiveJob::QueueAdapters::QueAdapter::JobWrapper',
-      :job_id => "ID",
-      :wrapper_job_class => 'ActiveJob::QueueAdapters::QueAdapter::JobWrapper',
-      :wrapper_job_id => "ID",
-      :queue => "foo",
-      :args => "bar"
-    })
-    expect(report).to receive(:severity=).with("error")
-    expect(report).to receive(:severity_reason=).with({
-      :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
-      :attributes => {
-        :framework => 'Que'
-      }
-    })
-
-    allow(Que).to receive(:respond_to?).with(:error_notifier=).and_return(true)
-    config = double('config')
-    allow(Bugsnag).to receive(:configuration).and_return(config)
-    expect(config).to receive(:app_type)
-    expect(config).to receive(:app_type=).with('que')
-    runtime = {}
-    expect(config).to receive(:runtime_versions).and_return(runtime)
-    allow(config).to receive(:clear_request_data)
-    expect(Que).to receive(:error_notifier=) do |handler|
-      handler.call(error, job)
-    end
-
-    #Kick off
-    load './lib/bugsnag/integrations/que.rb'
-    
-    expect(runtime).to eq("que" => "9.9.9")
-  end
-
-  context 'when the job is nil' do
-    it 'notifies Bugsnag' do
-      load './lib/bugsnag/integrations/que.rb'
-      error = RuntimeError.new('nil job')
-      report = Bugsnag::Report.new(error, Bugsnag::Configuration.new)
-      expect(Bugsnag).to receive(:notify).with(error, true).and_yield(report)
-
-      Que.error_notifier.call(error, nil)
-
-      expect(report.meta_data['custom'].fetch('job')).to eq(nil)
-      expect(report.severity).to eq('error')
-      expect(report.severity_reason).to eq({
-        :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
-        :attributes => {:framework => 'Que'},
-      })
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :Que) if @mocked_que
-    module Kernel
-      alias_method :require, :old_require
-    end
-  end
-end

data/spec/integrations/rack_spec.rb

@@ -1,230 +0,0 @@
-require 'spec_helper'
-
-describe Bugsnag::Rack do
-  it "calls the upstream rack app with the environment" do
-    rack_env = {"key" => "value"}
-    app = lambda { |env| ['response', {}, env] }
-    rack_stack = Bugsnag::Rack.new(app)
-
-    response = rack_stack.call(rack_env)
-
-    expect(response).to eq(['response', {}, rack_env])
-  end
-
-  context "when an exception is raised in rack middleware" do
-    # Build a fake crashing rack app
-    exception = BugsnagTestException.new("It crashed")
-    rack_env = {"key" => "value"}
-    app = lambda { |env| raise exception }
-    rack_stack = Bugsnag::Rack.new(app)
-
-    before do
-      unless defined?(::Rack)
-        @mocked_rack = true
-        class Rack
-          def self.release
-            '9.9.9'
-          end
-          class Request
-          end
-        end
-      end
-    end
-
-    it "re-raises the exception" do
-      expect { rack_stack.call(rack_env) }.to raise_error(BugsnagTestException)
-    end
-
-    it "delivers an exception if auto_notify is enabled" do
-      rack_stack.call(rack_env) rescue nil
-
-      expect(Bugsnag).to have_sent_notification{ |payload, headers|
-        exception_class = payload["events"].first["exceptions"].first["errorClass"]
-        expect(exception_class).to eq(exception.class.to_s)
-      }
-
-    end
-
-    it "applies the correct severity reason" do
-      rack_stack.call(rack_env) rescue nil
-
-      expect(Bugsnag).to have_sent_notification{ |payload, headers|
-        event = get_event_from_payload(payload)
-        expect(event["unhandled"]).to be true
-        expect(event["severityReason"]).to eq({
-          "type" => "unhandledExceptionMiddleware",
-          "attributes" => {
-            "framework" => "Rack"
-          }
-        })
-      }
-    end
-
-    it "applies the rack version" do
-      app = lambda { |env| raise BugsnagTestException.new("It crashed") }
-      rack_stack = Bugsnag::Rack.new(app)
-
-      expect(Bugsnag.configuration.runtime_versions["rack"]).to eq '9.9.9'
-    end
-
-    it "does not deliver an exception if auto_notify is disabled" do
-      Bugsnag.configure do |config|
-        config.auto_notify = false
-      end
-
-      rack_stack.call(rack_env) rescue nil
-
-      expect(Bugsnag).not_to have_sent_notification
-    end
-  end
-
-  context "when running against the middleware" do
-    before do
-      unless defined?(::Rack)
-        @mocked_rack = true
-        class Rack
-          def self.release
-            '9.9.9'
-          end
-          class Request
-          end
-        end
-      end
-    end
-
-    it "correctly redacts from url and referer any value indicated by meta_data_filters" do
-      callback = double
-      rack_env = {
-        :env => true,
-        :HTTP_REFERER => "https://bugsnag.com/about?email=hello@world.com&another_param=thing",
-        "rack.session" => {
-          :session => true
-        }
-      }
-
-      rack_request = double
-      rack_params = {
-        :param => 'test'
-      }
-      allow(rack_request).to receive_messages(
-        :params => rack_params,
-        :ip => "rack_ip",
-        :request_method => "TEST",
-        :path => "/TEST_PATH",
-        :scheme => "http",
-        :host => "test_host",
-        :port => 80,
-        :referer => "https://bugsnag.com/about?email=hello@world.com&another_param=thing",
-        :fullpath => "/TEST_PATH?email=hello@world.com&another_param=thing"
-      )
-      expect(::Rack::Request).to receive(:new).with(rack_env).and_return(rack_request)
-
-      # modify rack_env to include redacted referer
-      report = double("Bugsnag::Report")
-      allow(report).to receive(:request_data).and_return({
-        :rack_env => rack_env
-      })
-      expect(report).to receive(:context=).with("TEST /TEST_PATH")
-      expect(report).to receive(:user).and_return({})
-
-      config = double
-      allow(config).to receive(:send_environment).and_return(true)
-      allow(config).to receive(:meta_data_filters).and_return(['email'])
-      allow(report).to receive(:configuration).and_return(config)
-      expect(report).to receive(:add_tab).once.with(:request, {
-        :url => "http://test_host/TEST_PATH?email=[FILTERED]&another_param=thing",
-        :httpMethod => "TEST",
-        :params => rack_params,
-        :referer => "https://bugsnag.com/about?email=[FILTERED]&another_param=thing",
-        :clientIp => "rack_ip",
-        :headers => {
-          "Referer" => "https://bugsnag.com/about?email=[FILTERED]&another_param=thing"
-        }
-      })
-      # rack_env["HTTP_REFERER"] = "https://bugsnag.com/about?email=[FILTERED]&another_param=thing"
-      expect(report).to receive(:add_tab).once.with(:environment, rack_env)
-      expect(report).to receive(:add_tab).once.with(:session, {
-        :session => true
-      })
-
-      expect(callback).to receive(:call).with(report)
-
-      middleware = Bugsnag::Middleware::RackRequest.new(callback)
-      middleware.call(report)
-    end
-
-    it "correctly extracts data from rack middleware" do
-      callback = double
-      rack_env = {
-        :env => true,
-        :HTTP_test_key => "test_key",
-        "rack.session" => {
-          :session => true
-        }
-      }
-
-      rack_request = double
-      rack_params = {
-        :param => 'test'
-      }
-      allow(rack_request).to receive_messages(
-        :params => rack_params,
-        :ip => "rack_ip",
-        :request_method => "TEST",
-        :path => "/TEST_PATH",
-        :scheme => "http",
-        :host => "test_host",
-        :port => 80,
-        :referer => "referer",
-        :fullpath => "/TEST_PATH"
-      )
-      expect(Rack::Request).to receive(:new).with(rack_env).and_return(rack_request)
-
-      report = double("Bugsnag::Report")
-      allow(report).to receive(:request_data).and_return({
-        :rack_env => rack_env
-      })
-      expect(report).to receive(:context=).with("TEST /TEST_PATH")
-      expect(report).to receive(:user).and_return({})
-
-      config = double
-      allow(config).to receive(:send_environment).and_return(true)
-      allow(config).to receive(:meta_data_filters).and_return(nil)
-      allow(report).to receive(:configuration).and_return(config)
-      expect(report).to receive(:add_tab).once.with(:environment, rack_env)
-      expect(report).to receive(:add_tab).once.with(:request, {
-        :url => "http://test_host/TEST_PATH",
-        :httpMethod => "TEST",
-        :params => rack_params,
-        :referer => "referer",
-        :clientIp => "rack_ip",
-        :headers => {
-          "Test-Key" => "test_key"
-        }
-      })
-      expect(report).to receive(:add_tab).once.with(:session, {
-        :session => true
-      })
-
-      expect(callback).to receive(:call).with(report)
-
-      middleware = Bugsnag::Middleware::RackRequest.new(callback)
-      middleware.call(report)
-    end
-
-    after do
-      Object.send(:remove_const, :Rack) if @mocked_rack
-    end
-
-  end
-
-  it "don't mess with middlewares list on each req" do
-    app = lambda { |env| ['200', {}, ['']] }
-
-    Bugsnag::Rack.new(app)
-
-    expect { 2.times { Bugsnag::Rack.new(app) } }.not_to change {
-      Bugsnag.configuration.middleware.instance_variable_get(:@middlewares)
-    }
-  end
-end

data/spec/integrations/rails3_request_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe Bugsnag::Middleware::Rails3Request do
-  before(:each) do
-    Bugsnag.configuration.middleware.use(described_class)
-  end
-
-  describe "#call" do
-    it "sets request metadata" do
-      Bugsnag.configuration.set_request_data(:rack_env, {
-        "action_dispatch.remote_ip" => "10.2.2.224",
-        "action_dispatch.request_id" => "5",
-      })
-      Bugsnag.notify(BugsnagTestException.new('Grimbles'))
-
-      expect(Bugsnag).to have_sent_notification { |payload, headers|
-        event = get_event_from_payload(payload)
-        puts event["metaData"].inspect
-        expect(event["metaData"]["request"]).to eq({
-          "clientIp" => "10.2.2.224",
-          "requestId" => "5"
-        })
-      }
-    end
-
-    it "unsets request metadata" do
-      Bugsnag.configuration.set_request_data(:rack_env, {
-        "action_dispatch.remote_ip" => "10.2.2.224",
-        "action_dispatch.request_id" => "5",
-      })
-      Bugsnag.configuration.unset_request_data(:rack_env, nil)
-      Bugsnag.notify(BugsnagTestException.new('Grimbles'))
-
-      expect(Bugsnag).to have_sent_notification { |payload, headers|
-        event = get_event_from_payload(payload)
-        puts event["metaData"].inspect
-        expect(event["metaData"]["request"]).to be nil
-      }
-    end
-
-    context "the Remote IP will throw when serialized" do
-
-      it "sets the client IP metdata to [SPOOF]" do
-        class SpecialIP
-          def to_s
-            raise BugsnagTestException.new('oh no')
-          end
-        end
-        Bugsnag.configuration.set_request_data(:rack_env, {
-          "action_dispatch.remote_ip" => SpecialIP.new,
-          "action_dispatch.request_id" => "5",
-        })
-
-        Bugsnag.notify(BugsnagTestException.new('Grimbles'))
-
-        expect(Bugsnag).to have_sent_notification { |payload, headers|
-          event = get_event_from_payload(payload)
-          puts event["metaData"].inspect
-          expect(event["metaData"]["request"]).to eq({
-            "clientIp" => "[SPOOF]",
-            "requestId" => "5"
-          })
-        }
-      end
-    end
-  end
-end

data/spec/integrations/rake_spec.rb

@@ -1,71 +0,0 @@
-require 'webrick'
-require 'spec_helper'
-require 'json'
-
-describe "Bugsnag Rake integration" do
-  describe Bugsnag::Middleware::Rake do
-    it "adds rake data to the report" do
-      callback = double
-
-      task = double
-      allow(task).to receive_messages(
-        :name => "TEST_NAME",
-        :full_comment => "TEST_COMMENT",
-        :arg_description =>"TEST_ARGS"
-      )
-
-      report = double("Bugsnag::Report") 
-      expect(report).to receive(:request_data).and_return({
-        :bugsnag_running_task => task
-      })
-      expect(report).to receive(:add_tab).with(:rake_task, {
-        :name => "TEST_NAME",
-        :description => "TEST_COMMENT",
-        :arguments => "TEST_ARGS"
-      })
-      expect(report).to receive(:context).with(no_args)
-      expect(report).to receive(:context=).with("TEST_NAME")
-
-      expect(callback).to receive(:call).with(report)
-
-      middleware = Bugsnag::Middleware::Rake.new(callback)
-      middleware.call(report)
-    end
-  end
-
-  describe "Bugsnag::Rake" 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 run the rake middleware when rake tasks crash' do
-      ENV['BUGSNAG_TEST_SERVER_PORT'] = server.config[:Port].to_s
-      task_fixtures_path = File.join(File.dirname(__FILE__), '../fixtures', 'tasks')
-      Dir.chdir(task_fixtures_path) do
-        system("../../../bin/rake test:crash")
-      end
-
-      result = request()
-      expect(result["events"][0]["metaData"]["rake_task"]).not_to be_nil
-      expect(result["events"][0]["metaData"]["rake_task"]["name"]).to eq("test:crash")
-      expect(result["events"][0]["app"]["type"]).to eq("rake")
-      expect(result["events"][0]["device"]["runtimeVersions"]["rake"]).to match(/\A\d+\.\d+\.\d+/)
-    end
-  end
-end