honeybadger 1.16.7 → 2.0.0.beta.1

data/spec/honeybadger/integrations/delayed_job_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-require 'honeybadger/monitor'
-
-begin
-  require 'delayed_job'
-  require 'honeybadger/integrations/delayed_job/plugin'
-  DELAYED_JOB_INSTALLED = true
-rescue LoadError
-  DELAYED_JOB_INSTALLED = false
-  nil
-end
-
-if DELAYED_JOB_INSTALLED
-  # Prepend the load path with delayed_job's spec directory so that we can take
-  # advantage of their test backend:
-  # https://github.com/collectiveidea/delayed_job/blob/master/spec/delayed/backend/test.rb
-  $:.unshift(File.join(Gem::Specification.find_by_name('delayed_job').full_gem_path, 'spec'))
-  Delayed::Worker.backend = :test
-
-  class ExceptionTester
-    def null_method
-    end
-
-    def will_raise
-      raise "raised from will_raise"
-    end
-  end
-
-  describe "DelayedJob integration" do
-    let(:worker) { @worker }
-
-    before(:all) do
-      Delayed::Worker.plugins = [Honeybadger::Integrations::DelayedJob::Plugin]
-      @worker = Delayed::Worker.new
-    end
-
-    after { Delayed::Job.delete_all }
-
-    context "when a method is delayed" do
-      let(:method_name) { :null_method }
-
-      before { ExceptionTester.new.delay.send(method_name) }
-
-      specify { expect(Delayed::Job.count).to eq 1 }
-
-      it "queues a new trace" do
-        trace_id = nil
-        Honeybadger::Monitor.worker.should_receive(:queue_trace).once.and_return do
-          # This ensures that Honeybadger::Monitor.worker.trace is not nil when
-          # it's queued from the worker. There may still be an edge case where
-          # that's possible. (see #84)
-          trace_id = Thread.current[:hb_trace_id]
-        end
-        worker.work_off
-        expect(trace_id).not_to be_nil
-      end
-
-      context "and an exception occurs" do
-        let(:method_name) { :will_raise }
-
-        after  { worker.work_off }
-
-        it "notifies Honeybadger" do
-          Honeybadger.should_receive(:notify_or_ignore).once
-        end
-      end
-
-      context "and a threshold is set" do
-        let(:method_name) { :will_raise }
-
-        before { ::Honeybadger.configuration.delayed_job_attempt_threshold = 2 }
-        after { ::Honeybadger.configuration.delayed_job_attempt_threshold = 0 }
-
-        it "does not notify Honeybadger on first occurence" do
-          Honeybadger.should_not_receive(:notify_or_ignore)
-
-          worker.work_off
-        end
-      end
-    end
-  end
-end

data/spec/honeybadger/integrations/local_variables_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe "Local variables integration" do
-  before do
-    Honeybadger.configuration.send_local_variables = config_enabled
-    Honeybadger::Dependency.inject!
-  end
-
-  subject { Exception.new }
-
-  context "when binding_of_caller isn't installed", :unless => defined?(::BindingOfCaller) do
-    let(:config_enabled) { true }
-    it { should_not respond_to :__honeybadger_bindings_stack }
-  end
-
-  context "when binding_of_caller is installed", :if => defined?(::BindingOfCaller) do
-    context "and disabled by configuration" do
-      let(:config_enabled) { false }
-      it { should_not respond_to :__honeybadger_bindings_stack }
-    end
-
-    context "and enabled by configuration" do
-      let(:config_enabled) { true }
-
-      it { should respond_to :__honeybadger_bindings_stack }
-
-      describe "#set_backtrace" do
-        context "call stack does not match current file" do
-          it "changes the bindings stack" do
-            expect { subject.set_backtrace(['foo.rb:1']) }.to change(subject, :__honeybadger_bindings_stack).from([])
-          end
-        end
-
-        context "call stack includes current file" do
-          before do
-            subject.stub(:caller).and_return(["#{File.expand_path('../../../../lib/honeybadger/integrations/local_variables.rb', __FILE__)}:1"])
-          end
-
-          it "does not change the bindings stack" do
-            expect { subject.set_backtrace(['foo.rb:1']) }.not_to change(subject, :__honeybadger_bindings_stack).from([])
-          end
-        end
-
-        context "call stack includes a non-matching line" do
-          before do
-            subject.stub(:caller).and_return(['(foo)'])
-          end
-
-          it "skips the non-matching line" do
-            expect { subject.set_backtrace(['foo.rb:1']) }.not_to raise_error
-          end
-
-          it "changes the bindings stack" do
-            expect { subject.set_backtrace(['foo.rb:1']) }.to change(subject, :__honeybadger_bindings_stack).from([])
-          end
-        end
-      end
-    end
-  end
-end

data/spec/honeybadger/integrations/net_http_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-begin
-  require 'active_support/notifications'
-rescue LoadError
-  nil
-end
-
-describe "Net::HTTP Dependency" do
-  before do
-    Honeybadger::Dependency.reset!
-  end
-
-  if defined?(ActiveSupport::Notifications)
-    context "when active support notifications are installed" do
-      it "installs instrumentation" do
-        Honeybadger::Dependency.inject!
-        expect(Net::HTTP.instance_method(:request)).to eq Net::HTTP.instance_method(:request_with_honeybadger)
-      end
-    end
-  else
-    context "when active support notifications are not installed" do
-      it "does not install instrumentation" do
-        Honeybadger::Dependency.inject!
-        expect(Net::HTTP.instance_methods).not_to include(:request_with_honeybadger)
-      end
-    end
-  end
-end

data/spec/honeybadger/integrations/passenger_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe "Passenger integration" do
-  before do
-    Honeybadger::Dependency.reset!
-  end
-
-  context "when passenger is not installed" do
-    it "fails quietly" do
-      expect { Honeybadger::Dependency.inject! }.not_to raise_error
-    end
-  end
-
-  context "when passenger is installed" do
-    let(:shim) { double('PhusionPassenger') }
-
-    before do
-      Object.const_set(:PhusionPassenger, shim)
-    end
-    after { Object.send(:remove_const, :PhusionPassenger) }
-
-    it "installs passenger hooks" do
-      shim.should_receive(:on_event).with(:starting_worker_process)
-      shim.should_receive(:on_event).with(:stopping_worker_process)
-      Honeybadger::Dependency.inject!
-    end
-  end
-end
-

data/spec/honeybadger/integrations/sidekiq_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe "Sidekiq Dependency" do
-  before do
-    Honeybadger::Dependency.reset!
-  end
-
-  context "when sidekiq is not installed" do
-    it "fails quietly" do
-      expect { Honeybadger::Dependency.inject! }.not_to raise_error
-    end
-  end
-
-  context "when sidekiq is installed" do
-    let(:shim) do
-      Class.new do
-        def self.configure_server
-        end
-      end
-    end
-
-    let(:config) { double('config', :error_handlers => []) }
-    let(:chain) { double('chain', :add => true) }
-
-    before do
-      Object.const_set(:Sidekiq, shim)
-      ::Sidekiq.stub(:configure_server).and_yield(config)
-      config.stub(:server_middleware).and_yield(chain)
-    end
-
-    after { Object.send(:remove_const, :Sidekiq) }
-
-    context "when version is less than 3" do
-      before do
-        ::Sidekiq.const_set(:VERSION, '2.17.7')
-      end
-
-      it "adds the server middleware" do
-        chain.should_receive(:add).with(Honeybadger::Integrations::Sidekiq::Middleware)
-        Honeybadger::Dependency.inject!
-      end
-
-      it "doesn't add the error handler" do
-        Honeybadger::Dependency.inject!
-        expect(config.error_handlers).to be_empty
-      end
-    end
-
-    context "when version is 3 or greater" do
-      before do
-        ::Sidekiq.const_set(:VERSION, '3.0.0')
-      end
-
-      it "adds the error handler" do
-        Honeybadger::Dependency.inject!
-        expect(config.error_handlers).not_to be_empty
-      end
-    end
-  end
-end

data/spec/honeybadger/integrations/thor_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe "Thor Dependency" do
-  before do
-    Honeybadger::Dependency.reset!
-  end
-
-  context "when thor is not installed" do
-    it "fails quietly" do
-      expect { Honeybadger::Dependency.inject! }.not_to raise_error
-    end
-  end
-
-  context "when thor is installed" do
-    let(:shim) do
-      Class.new do
-        def self.no_commands
-        end
-      end
-    end
-
-    before do
-      Object.const_set(:Thor, shim)
-    end
-    after { Object.send(:remove_const, :Thor) }
-
-    it "includes integration module into Thor" do
-      shim.should_receive(:send).with(:include, Honeybadger::Integrations::Thor)
-      Honeybadger::Dependency.inject!
-    end
-  end
-end

data/spec/honeybadger/integrations/unicorn_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe "Unicorn integration" do
-  before do
-    Honeybadger::Dependency.reset!
-  end
-
-  context "when unicorn is not installed" do
-    it "fails quietly" do
-      expect { Honeybadger::Dependency.inject! }.not_to raise_error
-    end
-  end
-
-  context "when unicorn is installed" do
-    let(:shim) {
-      Class.new {
-        def init_worker_process(worker)
-          'foo'
-        end
-      }
-    }
-
-    before do
-      Object.const_set(:Unicorn, Module.new)
-      Unicorn.const_set(:HttpServer, shim)
-    end
-    after { Object.send(:remove_const, :Unicorn) }
-
-    it "logs installation" do
-      Honeybadger.should_receive(:write_verbose_log).with(/Unicorn/)
-      Honeybadger::Dependency.inject!
-    end
-
-    it "installs unicorn hooks" do
-      Honeybadger::Dependency.inject!
-      Honeybadger::Monitor.worker.should_receive(:fork)
-      expect(shim.new.init_worker_process(double('worker'))).to eq 'foo'
-    end
-  end
-end

data/spec/honeybadger/logger_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-describe Honeybadger do
-  def send_notice
-    Honeybadger.sender.send_to_honeybadger('data')
-  end
-
-  def stub_verbose_log
-    Honeybadger.stub(:write_verbose_log)
-  end
-
-  def configure
-    Honeybadger.configure { |config| }
-  end
-
-  it "reports that notifier is ready when configured" do
-    stub_verbose_log
-    Honeybadger.should_receive(:write_verbose_log).with(/Notifier (.*) ready/, anything)
-    configure
-  end
-
-  it "does not report that notifier is ready when internally configured" do
-    stub_verbose_log
-    Honeybadger.should_not_receive(:write_verbose_log)
-    Honeybadger.configure(true) { |config| }
-  end
-
-  it "prints environment info on a failed notification without a body" do
-    reset_config
-    stub_verbose_log
-    stub_http(:response => Net::HTTPError, :body => nil)
-    Honeybadger.should_receive(:write_verbose_log).with(/Environment Info:/)
-    Honeybadger.should_not_receive(:write_verbose_log).with(/Response from Honeybadger:/, anything)
-    send_notice
-  end
-
-  it "prints environment info and response on a success with a body" do
-    reset_config
-    stub_verbose_log
-    stub_http
-    Honeybadger.should_receive(:write_verbose_log).with(/Environment Info:/)
-    Honeybadger.should_receive(:write_verbose_log).with(/Response from Honeybadger:/)
-    send_notice
-  end
-
-  it "prints environment info and response on a failure with a body" do
-    reset_config
-    stub_verbose_log
-    stub_http(:response => Net::HTTPError)
-    Honeybadger.should_receive(:write_verbose_log).with(/Environment Info:/)
-    Honeybadger.should_receive(:write_verbose_log).with(/Response from Honeybadger:/)
-    send_notice
-  end
-
-  context "429 error response" do
-    let(:failure_class) do
-      if RUBY_VERSION !~ /^1/
-        Net::HTTPTooManyRequests
-      else
-        Net::HTTPClientError
-      end
-    end
-
-    let(:http) { stub_http(:response => failure_class.new('1.2', '429', 'Peace out'), :body => '{"error":"something went wrong"}') }
-
-    before do
-      reset_config
-      stub_verbose_log
-    end
-
-    it "logs the response" do
-      http.should_receive(:post).with(Honeybadger::Sender::NOTICES_URI, kind_of(String), kind_of(Hash))
-      Honeybadger.should_receive(:write_verbose_log).with(/Failure: #{failure_class.name}/, :error)
-      Honeybadger.should_receive(:write_verbose_log).with(/Environment Info:/)
-      Honeybadger.should_receive(:write_verbose_log).with(/something went wrong/)
-      Honeybadger.notify(RuntimeError.new('oops!'))
-    end
-  end
-end

data/spec/honeybadger/monitor/trace_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-require 'honeybadger/monitor'
-
-describe Honeybadger::Monitor::Trace do
-  describe "::instrument" do
-    before do
-      Honeybadger::Monitor::Trace.stub(:generate_secure_id).and_return(:foo)
-    end
-
-    it "creates a new trace" do
-      Honeybadger::Monitor::Trace.should_receive(:new).and_call_original
-      described_class.instrument('testing', {}){}
-    end
-
-    it "temporarily stores trace id in thread local" do
-      described_class.instrument('testing', {}) do
-        expect(Thread.current[:hb_trace_id]).to eq :foo
-      end
-
-      expect(Thread.current[:hb_trace_id]).to be_nil
-    end
-
-    it "stores the trace on the worker's pending traces" do
-      described_class.instrument('testing', {}) do
-        expect(Honeybadger::Monitor.worker.pending_traces[:foo]).to be_a Honeybadger::Monitor::Trace
-      end
-
-      expect(Honeybadger::Monitor.worker.pending_traces[:foo]).to be_nil
-    end
-  end
-end
-
-begin
-  require 'active_support/notifications'
-  require 'active_record'
-
-  describe Honeybadger::Monitor::TraceCleaner::ActiveRecord do
-    let(:event) do
-      ::ActiveSupport::Notifications::Event.new(
-        'sql.active_record', # name
-        now = Time.now.to_f, # start
-        now+0.2,             # ending
-        '1',                 # transaction_id
-        {                    # payload
-          :name => nil,
-          :sql => '',
-          :binds => [],
-          :connection_id => 123
-        }
-      )
-    end
-
-    before do
-      ::ActiveRecord::Base.stub(:connection_pool).and_return(double(:spec => double(:config => {})))
-    end
-
-    # This will fail if the configuration is accessed through
-    # `ActiveRecord::Base.connection_config` in rails < 3.1.
-    it "safely accesses connection configuration" do
-      expect { described_class.new(event).to_s }.not_to raise_error
-    end
-  end
-rescue LoadError
-  nil
-end