bugsnag 6.15.0 → 6.20.0

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

data/spec/integrations/mongo_spec.rb

@@ -1,262 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe 'Bugsnag::MongoBreadcrumbSubscriber', :order => :defined do
-  before do
-    unless defined?(::Mongo)
-      @mocked_mongo = true
-      module ::Mongo
-        module Monitoring
-          COMMAND = 'Command'
-          module Global
-          end
-        end
-      end
-      module Kernel
-        alias_method :old_require, :require
-        def require(path)
-          old_require(path) unless path == 'mongo'
-        end
-      end
-    end
-  end
-
-  it "should subscribe to the mongo monitoring service" do
-    expect(::Mongo::Monitoring::Global).to receive(:subscribe) do |command, subscriber|
-      expect(command).to eq(::Mongo::Monitoring::COMMAND)
-      expect(subscriber).to be_an_instance_of(::Bugsnag::MongoBreadcrumbSubscriber)
-    end
-    load './lib/bugsnag/integrations/mongo.rb'
-  end
-
-  context "with the module loaded" do
-    before do
-      allow(::Mongo::Monitoring::Global).to receive(:subscribe)
-      require './lib/bugsnag/integrations/mongo'
-    end
-
-    let(:subscriber) { Bugsnag::MongoBreadcrumbSubscriber.new }
-
-    describe "#started" do
-      it "calls #leave_command with the event" do
-        event = double
-        expect(subscriber).to receive(:leave_command).with(event)
-        subscriber.started(event)
-      end
-    end
-
-    describe "#succeeded" do
-      it "calls #leave_mongo_breadcrumb with the event_name and event" do
-        event = double
-        expect(subscriber).to receive(:leave_mongo_breadcrumb).with("succeeded", event)
-        subscriber.succeeded(event)
-      end
-    end
-
-    describe "#failed" do
-      it "calls #leave_mongo_breadcrumb with the event_name and event" do
-        event = double
-        expect(subscriber).to receive(:leave_mongo_breadcrumb).with("failed", event)
-        subscriber.failed(event)
-      end
-    end
-
-    describe "#leave_mongo_breadcrumb" do
-      let(:event) { double(
-        :command_name => "command",
-        :database_name => "database",
-        :operation_id => "1234567890",
-        :request_id => "123456",
-        :duration => "123.456"
-      ) }
-      let(:event_name) { "event_name" }
-      it "leaves a breadcrumb with relevant meta_data, message, type, and automatic notation" do
-        expect(Bugsnag).to receive(:leave_breadcrumb).with(
-          "Mongo query #{event_name}",
-          {
-            :event_name => "mongo.#{event_name}",
-            :command_name => "command",
-            :database_name => "database",
-            :operation_id => "1234567890",
-            :request_id => "123456",
-            :duration => "123.456"
-          },
-          "process",
-          :auto
-        )
-        subscriber.send(:leave_mongo_breadcrumb, event_name, event)
-      end
-
-      it "adds message data if present" do
-        allow(event).to receive(:message).and_return("This is a message")
-        expect(Bugsnag).to receive(:leave_breadcrumb).with(
-          "Mongo query #{event_name}",
-          {
-            :event_name => "mongo.#{event_name}",
-            :command_name => "command",
-            :database_name => "database",
-            :operation_id => "1234567890",
-            :request_id => "123456",
-            :duration => "123.456",
-            :message => "This is a message"
-          },
-          "process",
-          :auto
-        )
-        subscriber.send(:leave_mongo_breadcrumb, event_name, event)
-      end
-
-      context "command data is present" do
-        let(:command) {
-          {
-            "command" => "collection_name_command",
-            "collection" => "collection_name_getMore",
-            "filter" => nil
-          }
-        }
-
-        it "adds the collection name" do
-          expect(subscriber).to receive(:pop_command).with("123456").and_return(command)
-          expect(Bugsnag).to receive(:leave_breadcrumb).with(
-            "Mongo query #{event_name}",
-            {
-              :event_name => "mongo.#{event_name}",
-              :command_name => "command",
-              :database_name => "database",
-              :operation_id => "1234567890",
-              :request_id => "123456",
-              :duration => "123.456",
-              :collection => "collection_name_command"
-            },
-            "process",
-            :auto
-          )
-          subscriber.send(:leave_mongo_breadcrumb, event_name, event)
-        end
-
-        it "adds the correct collection name for 'getMore' commands" do
-          allow(event).to receive(:command_name).and_return("getMore")
-          expect(subscriber).to receive(:pop_command).with("123456").and_return(command)
-          expect(Bugsnag).to receive(:leave_breadcrumb).with(
-            "Mongo query #{event_name}",
-            {
-              :event_name => "mongo.#{event_name}",
-              :command_name => "getMore",
-              :database_name => "database",
-              :operation_id => "1234567890",
-              :request_id => "123456",
-              :duration => "123.456",
-              :collection => "collection_name_getMore"
-            },
-            "process",
-            :auto
-          )
-          subscriber.send(:leave_mongo_breadcrumb, event_name, event)
-        end
-
-        it "adds a JSON string of filter data" do
-          command["filter"] = {"a" => 1, "b" => 2, "$or" => [{"c" => 3}, {"d" => 4}]}
-          expect(subscriber).to receive(:pop_command).with("123456").and_return(command)
-          expect(Bugsnag).to receive(:leave_breadcrumb).with(
-            "Mongo query #{event_name}",
-            {
-              :event_name => "mongo.#{event_name}",
-              :command_name => "command",
-              :database_name => "database",
-              :operation_id => "1234567890",
-              :request_id => "123456",
-              :duration => "123.456",
-              :collection => "collection_name_command",
-              :filter => '{"a":"?","b":"?","$or":[{"c":"?"},{"d":"?"}]}'
-            },
-            "process",
-            :auto
-          )
-          subscriber.send(:leave_mongo_breadcrumb, event_name, event)
-        end
-      end
-    end
-
-    describe "#sanitize_filter_hash" do
-      it "calls into #sanitize_filter_value with the value from each {k,v} pair" do
-        expect(subscriber.send(:sanitize_filter_hash, {:a => 1, :b => 2})).to eq({:a => '?', :b => '?'})
-      end
-    end
-
-    describe "#sanitize_filter_value" do
-      it "returns '?' for strings, numbers, booleans, and nil" do
-        expect(subscriber.send(:sanitize_filter_value, 523, 0)).to eq('?')
-        expect(subscriber.send(:sanitize_filter_value, "string", 0)).to eq('?')
-        expect(subscriber.send(:sanitize_filter_value, true, 0)).to eq('?')
-        expect(subscriber.send(:sanitize_filter_value, nil, 0)).to eq('?')
-      end
-
-      it "is recursive and iterative for array values" do
-        expect(subscriber.send(:sanitize_filter_value, [1, [2, [3]]], 0)).to eq(['?', ['?', ['?']]])
-      end
-
-      it "calls #sanitize_filter_hash for hash values" do
-        expect(subscriber).to receive(:sanitize_filter_hash).with({:a => 1}, 1)
-        subscriber.send(:sanitize_filter_value, {:a => 1}, 0)
-      end
-
-      it "returns [MAX_FILTER_DEPTH_REACHED] if the filter depth is exceeded" do
-        expect(subscriber.send(:sanitize_filter_value, 1, 4)).to eq('[MAX_FILTER_DEPTH_REACHED]')
-      end
-    end
-
-    describe "#leave_command" do
-      it "extracts and stores the command by request_id" do
-        request_id = "123456"
-        command = "this is a command string"
-        event = double(:command => command, :request_id => request_id)
-
-        subscriber.send(:leave_command, event)
-        command_hash = Bugsnag.configuration.request_data[Bugsnag::MongoBreadcrumbSubscriber::MONGO_COMMAND_KEY]
-        expect(command_hash[request_id]).to eq(command)
-      end
-    end
-
-    describe "#pop_command" do
-      let(:request_id) { "123456" }
-      let(:command) { "this is a command string" }
-      before do
-        event = double(:command => command, :request_id => request_id)
-        subscriber.send(:leave_command, event)
-      end
-
-      it "returns the command given a request_id" do
-        expect(subscriber.send(:pop_command, request_id)).to eq(command)
-      end
-
-      it "removes the command from the request_data" do
-        subscriber.send(:pop_command, request_id)
-        command_hash = Bugsnag.configuration.request_data[Bugsnag::MongoBreadcrumbSubscriber::MONGO_COMMAND_KEY]
-        expect(command_hash).not_to have_key(request_id)
-      end
-
-      it "returns nil if the request_id is not found" do
-        expect(subscriber.send(:pop_command, "09876")).to be_nil
-      end
-    end
-
-    describe "#event_commands" do
-      it "returns a hash" do
-        expect(subscriber.send(:event_commands)).to be_a(Hash)
-      end
-
-      it "is stored in request data" do
-        subscriber.send(:event_commands)[:key] = "value"
-        command_hash = Bugsnag.configuration.request_data[Bugsnag::MongoBreadcrumbSubscriber::MONGO_COMMAND_KEY]
-        expect(command_hash[:key]).to eq("value")
-      end
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :Mongo) if @mocked_mongo
-    module Kernel
-      alias_method :require, :old_require
-    end
-  end
-end