bugsnag 6.15.0 → 6.27.1

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

data/spec/integrations/resque_spec.rb

@@ -1,99 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe 'Bugsnag::Resque', :order => :defined do
-  before do
-    unless defined?(::Resque)
-      @mocked_resque = true
-      class ::Resque
-        VERSION = '9.9.9'
-        class Worker
-        end
-        class Failure
-          class Bugsnag
-          end
-          class Base
-          end
-          class Multiple
-          end
-        end
-      end
-      module Kernel
-        alias_method :old_require, :require
-        def require(path)
-          old_require(path) unless /^resque/.match(path)
-        end
-      end
-    end
-  end
-
-  it "should load Bugsnag::Resque" do
-    #Auto-load failure backend
-    backend = double('backend')
-    allow(::Resque::Failure).to receive(:backend).and_return(backend)
-    expect(backend).to receive(:<).and_return(nil)
-    expect(::Resque::Failure).to receive(:backend=).with(::Resque::Failure::Multiple)
-    classes = double('classes')
-    allow(backend).to receive(:classes).and_return(classes)
-    expect(classes).to receive(:<<).with(backend)
-    expect(classes).to receive(:include?).and_return(false)
-    expect(classes).to receive(:<<)
-
-    #Bugsnag fork check
-    fork_check = double("fork_check")
-    expect(::Resque::Worker).to receive(:new).with(:bugsnag_fork_check).and_return(fork_check)
-    expect(fork_check).to receive(:fork_per_job?).and_return(true)
-    expect(::Resque).to receive(:after_fork).and_yield
-    expect(Bugsnag.configuration).to receive(:app_type=).with("resque")
-    runtime = {}
-    expect(Bugsnag.configuration).to receive(:runtime_versions).and_return(runtime)
-    expect(Bugsnag.configuration).to receive(:default_delivery_method=).with(:synchronous)
-
-    #Kick off
-    require './lib/bugsnag/integrations/resque'
-
-    expect(runtime).to eq("resque" => "9.9.9")
-  end
-
-  it "can configure" do
-    expect(Bugsnag::Resque).to receive(:add_failure_backend)
-    expect(Bugsnag).to receive(:configure).and_yield
-    Bugsnag::Resque.configure do
-    end
-  end
-
-  it "can save data" do
-    resque = Bugsnag::Resque.new
-    exception = double('exception')
-    allow(resque).to receive(:exception).and_return(exception)
-    allow(resque).to receive(:payload).and_return({
-      "class" => "class"
-    })
-    allow(resque).to receive(:queue).and_return("queue")
-    report = double('report')
-    expect(report).to receive(:severity=).with("error")
-    expect(report).to receive(:severity_reason=).with({
-      :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
-      :attributes => Bugsnag::Resque::FRAMEWORK_ATTRIBUTES
-    })
-    expected_context = "class@queue"
-    meta_data = double('meta_data')
-    expect(report).to receive(:meta_data).and_return(meta_data)
-    expect(meta_data).to receive(:merge!).with({
-      :context => expected_context,
-      :payload => {
-        "class" => "class"
-      }
-    })
-    expect(report).to receive(:context=).with(expected_context)
-    expect(Bugsnag).to receive(:notify).with(exception, true).and_yield(report)
-    resque.save
-  end
-
-  after do
-    Object.send(:remove_const, :Resque) if @mocked_resque
-    module Kernel
-      alias_method :require, :old_require
-    end
-  end
-end

data/spec/integrations/shoryuken_spec.rb

@@ -1,70 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe 'Bugsnag::Shoryuken', :order => :defined do
-  before do
-    unless defined?(::Shoryuken)
-      @mocked_shoryuken = true
-      class ::Shoryuken
-      end
-      module Kernel
-        alias_method :old_require, :require
-        def require(path)
-          old_require(path) unless path == 'shoryuken'
-        end
-      end
-    end
-  end
-
-  it "should call configure_server" do
-    chain = double("chain")
-    expect(chain).to receive(:add).with(anything())
-    config = double("config")
-    expect(config).to receive(:server_middleware).and_yield(chain)
-    expect(::Shoryuken).to receive(:configure_server).and_yield(config)
-
-    require './lib/bugsnag/integrations/shoryuken'
-  end
-
-  it "calls configure when initialised" do
-    config = double("config")
-    
-    expect(config).to receive(:app_type).and_return(nil)
-    expect(config).to receive(:app_type=).with("shoryuken")
-    expect(config).to receive(:default_delivery_method=).with(:synchronous)
-    expect(Bugsnag).to receive(:configure).and_yield(config)
-    Bugsnag::Shoryuken.new
-  end
-
-  it "calls correct sequence when called" do
-    queue = 'queue'
-    body = 'body'
-
-    callbacks = double('callbacks')
-    expect(callbacks).to receive(:<<) do |func|
-      report = double('report')
-      expect(report).to receive(:add_tab).with(:shoryuken, {
-        queue: queue,
-        body: body
-      })
-      func.call(report)
-    end
-    config = double('config')
-    allow(config).to receive(:app_type).and_return(nil)
-    allow(config).to receive(:app_type=).with("shoryuken")
-    allow(config).to receive(:default_delivery_method=).with(:synchronous)
-    allow(config).to receive(:clear_request_data)
-    expect(Bugsnag).to receive(:before_notify_callbacks).and_return(callbacks)
-    allow(Bugsnag).to receive(:configure).and_yield(config)
-    allow(Bugsnag).to receive(:configuration).and_return(config)
-    shoryuken = Bugsnag::Shoryuken.new
-    expect { |b| shoryuken.call('_', queue, '_', body, &b )}.to yield_control
-  end
-
-  after do
-    Object.send(:remove_const, :Shoryuken) if @mocked_shoryuken
-    module Kernel
-      alias_method :require, :old_require
-    end
-  end
-end

data/spec/integrations/sidekiq_spec.rb

@@ -1,137 +0,0 @@
-require 'spec_helper'
-require 'sidekiq/testing'
-
-class Worker
-  include Sidekiq::Worker
-  def perform(value)
-    puts "Work: #{100/value}"
-  end
-end
-
-describe Bugsnag::Sidekiq do
-  # Integration testing v3 is handled by maze as sidekiq doesnt
-  # support error_handlers in testing mode
-  context "integration tests in v2" do
-    before do
-      Sidekiq::Testing.inline!
-      stub_const('Sidekiq::VERSION', '2.0.0')
-      Sidekiq::Testing.server_middleware do |chain|
-        chain.add ::Bugsnag::Sidekiq
-      end
-    end
-
-    it "works" do
-      expect{ Worker.perform_async(-0) }.to raise_error(ZeroDivisionError)
-
-      expect(Bugsnag).to have_sent_notification {|payload, headers|
-        event = get_event_from_payload(payload)
-        expect(event["metaData"]["sidekiq"]["msg"]["class"]).to eq("Worker")
-        expect(event["metaData"]["sidekiq"]["msg"]["args"]).to eq([-0])
-        expect(event["metaData"]["sidekiq"]["msg"]["queue"]).to eq("default")
-        expect(event["severity"]).to eq("error")
-        expect(event["app"]["type"]).to eq("sidekiq")
-        expect(event["device"]["runtimeVersions"]["sidekiq"]).to eq('2.0.0')
-      }
-    end
-  end
-
-  context "initializing the integrations" do
-    it "works in v2" do
-      config = double
-      expect(::Sidekiq).to receive(:configure_server).and_yield(config)
-      stub_const('Sidekiq::VERSION', '2.0.0')
-
-      chain = double
-      expect(config).to receive(:server_middleware).and_yield(chain)
-      expect(chain).to receive(:add).with(::Bugsnag::Sidekiq)
-
-      load './lib/bugsnag/integrations/sidekiq.rb'
-    end
-
-    it "works in v3" do
-      config = double
-      expect(::Sidekiq).to receive(:configure_server).and_yield(config)
-      stub_const('Sidekiq::VERSION', '3.0.0')
-
-      error_handlers = []
-      expect(config).to receive(:error_handlers).and_return(error_handlers)
-
-      chain = double
-      expect(config).to receive(:server_middleware).and_yield(chain)
-      expect(chain).to receive(:add).with(::Bugsnag::Sidekiq)
-
-      load './lib/bugsnag/integrations/sidekiq.rb'
-      expect(error_handlers.size).to eq(1)
-    end
-  end
-
-  context "ensuring data reset" do
-    context "v2" do
-      before do
-        Sidekiq::Testing.inline!
-        stub_const('Sidekiq::VERSION', '2.0.0')
-        Sidekiq::Testing.server_middleware do |chain|
-          chain.add ::Bugsnag::Sidekiq
-        end
-      end
-
-      it "resets with an exception" do
-        expect(Bugsnag.configuration).to receive(:set_request_data).with(:sidekiq, hash_including(:queue => "default"))
-        expect(Bugsnag.configuration).to receive(:clear_request_data).at_least(:once)
-        expect{ Worker.perform_async(-0) }.to raise_error(ZeroDivisionError)
-      end
-
-      it "resets without an exception" do
-        expect(Bugsnag.configuration).to receive(:set_request_data).with(:sidekiq, hash_including(:queue => "default"))
-        expect(Bugsnag.configuration).to receive(:clear_request_data).at_least(:once)
-        expect{ Worker.perform_async(1) }.to_not raise_error
-      end
-    end
-
-    context "v3" do
-      before do
-        Sidekiq::Testing.inline!
-        stub_const('Sidekiq::VERSION', '3.0.0')
-        Sidekiq::Testing.server_middleware do |chain|
-          chain.add ::Bugsnag::Sidekiq
-        end
-      end
-
-      it "doesn't reset with an exception" do
-        # This test ensures that when an exception occurs the request data isn't immediately reset
-        expect(Bugsnag.configuration).to receive(:set_request_data).with(:sidekiq, hash_including(:queue => "default"))
-        # Always received once due to the spec_helper setup
-        expect(Bugsnag.configuration).to receive(:clear_request_data).once
-        expect{ Worker.perform_async(-0) }.to raise_error(ZeroDivisionError)
-      end
-
-      it "resets without an exception" do
-        expect(Bugsnag.configuration).to receive(:set_request_data).with(:sidekiq, hash_including(:queue => "default"))
-        expect(Bugsnag.configuration).to receive(:clear_request_data).twice
-        expect{ Worker.perform_async(1) }.to_not raise_error
-      end
-
-      it "always resets in the error handler" do
-        config = double
-        allow(::Sidekiq).to receive(:configure_server).and_yield(config)
-
-        error_handlers = []
-        allow(config).to receive(:error_handlers).and_return(error_handlers)
-
-        chain = double
-        allow(config).to receive(:server_middleware).and_yield(chain)
-        allow(chain).to receive(:add).with(::Bugsnag::Sidekiq)
-
-        Bugsnag::Sidekiq.configure_server(config)
-
-        expect(error_handlers.size).to equal(1)
-
-        ex = double
-        expect(Bugsnag::Sidekiq).to receive(:notify).with(ex)
-        expect(Bugsnag.configuration).to receive(:clear_request_data).twice
-
-        error_handlers[0].call(ex)
-      end
-    end
-  end
-end

data/spec/integrations/warden_user_spec.rb

@@ -1,41 +0,0 @@
-require "spec_helper"
-
-describe Bugsnag::Middleware::WardenUser 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"
-    )
-
-    warden = double
-    allow(warden).to receive(:user).with(
-      :scope => "user",
-      :run_callbacks => false
-    ).and_return(user)
-
-    report = double("Bugsnag::Report") 
-    expect(report).to receive(:request_data).exactly(3).times.and_return({
-      :rack_env => {
-        "warden" => warden,
-        "rack.session" => {
-          "warden.user.user.key" => "TEST_USER"
-        }
-      }
-    })
-
-    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::WardenUser.new(callback)
-    middleware.call(report)
-  end
-end

data/spec/middleware/exception_meta_data_spec.rb

@@ -1,104 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Bugsnag::Middleware::ExceptionMetaData do
-  let(:report_class) do
-    Class.new do
-      attr_accessor :raw_exceptions, :tabs, :user, :context, :grouping_hash
-
-      def initialize(errors)
-        self.raw_exceptions = Array(errors)
-      end
-
-      def add_tab(key, value)
-        self.tabs ||= {}
-        tabs[key] = value
-      end
-    end
-  end
-
-  let(:middleware) { Bugsnag::Middleware::ExceptionMetaData.new(lambda {|_|}) }
-  let(:bugsnag_error_class) { Class.new(StandardError) { include Bugsnag::MetaData } }
-
-  it "adds metadata when exception singleton class extended with Bugsnag::MetaData" do
-    error = RuntimeError.new
-    error.extend(Bugsnag::MetaData)
-    error.bugsnag_meta_data = {"foo" => "bar"}
-
-    report = report_class.new(error)
-
-    middleware.call(report)
-
-    expect(report.tabs).to eq({"foo" => "bar"})
-  end
-
-  it "adds metadata when exception class includes Bugsnag::MetaData" do
-    error = bugsnag_error_class.new
-    error.bugsnag_meta_data = {"foo" => "bar"}
-
-    report = report_class.new(error)
-
-    middleware.call(report)
-
-    expect(report.tabs).to eq({"foo" => "bar"})
-  end
-
-  it "does nothing when metadata not a Hash" do
-    error = bugsnag_error_class.new
-    error.bugsnag_meta_data = 4
-
-    report = report_class.new(error)
-
-    middleware.call(report)
-
-    expect(report.user).to eq(nil)
-    expect(report.tabs).to eq(nil)
-    expect(report.grouping_hash).to eq(nil)
-    expect(report.context).to eq(nil)
-  end
-
-  it "sets user ID when a string" do
-    error = bugsnag_error_class.new
-    error.bugsnag_user_id = "1234"
-
-    report = report_class.new(error)
-
-    middleware.call(report)
-
-    expect(report.user).to eq({id: "1234"})
-  end
-
-  it "sets context when a string" do
-    error = bugsnag_error_class.new
-    error.bugsnag_context = "Foo#bar"
-
-    report = report_class.new(error)
-
-    middleware.call(report)
-
-    expect(report.context).to eq("Foo#bar")
-  end
-
-  it "sets grouping_hash when a string" do
-    error = bugsnag_error_class.new
-    error.bugsnag_grouping_hash = "abcdef"
-
-    report = report_class.new(error)
-
-    middleware.call(report)
-
-    expect(report.grouping_hash).to eq("abcdef")
-  end
-
-  it "does nothing when no bugsnag attributes are set" do
-    error = bugsnag_error_class.new
-    report = report_class.new(error)
-
-    middleware.call(report)
-
-    expect(report.user).to eq(nil)
-    expect(report.tabs).to eq(nil)
-    expect(report.grouping_hash).to eq(nil)
-    expect(report.context).to eq(nil)
-  end
-end