honeybadger 1.12.0.beta3 → 1.13.0

data/lib/honeybadger/rack/user_feedback.rb

@@ -1,74 +0,0 @@
-require 'erb'
-require 'uri'
-
-begin
-  require 'i18n'
-rescue LoadError
-  module Honeybadger
-    module I18n
-      def self.t(key, options={})
-        options[:default]
-      end
-    end
-  end
-end
-
-module Honeybadger
-  module Rack
-    class UserFeedback
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        status, headers, body = @app.call(env)
-        if enabled? && env['honeybadger.error_id'] && form = render_form(env['honeybadger.error_id'])
-          new_body = []
-          body.each do |chunk|
-            new_body << chunk.gsub("<!-- HONEYBADGER FEEDBACK -->", form)
-          end
-          body.close if body.respond_to?(:close)
-          headers['Content-Length'] = new_body.reduce(0) { |a,e| a += e.bytesize }.to_s
-          body = new_body
-        end
-        [status, headers, body]
-      end
-
-      def config
-        Honeybadger.configuration
-      end
-
-      def enabled?
-        config.feedback && config.features['feedback']
-      end
-
-      def action
-        URI.parse("#{config.protocol}://#{config.host}:#{config.port}/v1/feedback/").to_s
-      rescue URI::InvalidURIError
-        nil
-      end
-
-      def render_form(error_id, action = action)
-        return unless action
-        ERB.new(@template ||= File.read(template_file)).result(binding)
-      end
-
-      def custom_template_file
-        @custom_template_file ||= config.project_root &&
-          File.join(config.project_root, 'lib', 'honeybadger', 'templates', 'feedback_form.erb')
-      end
-
-      def custom_template_file?
-        custom_template_file && File.exists?(custom_template_file)
-      end
-
-      def template_file
-        if custom_template_file?
-          custom_template_file
-        else
-          File.expand_path('../../templates/feedback_form.erb', __FILE__)
-        end
-      end
-    end
-  end
-end

data/lib/honeybadger/rack/user_informer.rb

@@ -1,28 +0,0 @@
-module Honeybadger
-  module Rack
-    class UserInformer
-      def initialize(app)
-        @app = app
-      end
-
-      def replacement(with)
-        Honeybadger.configuration.user_information.gsub(/\{\{\s*error_id\s*\}\}/, with.to_s)
-      end
-
-      def call(env)
-        status, headers, body = @app.call(env)
-        if env['honeybadger.error_id'] && Honeybadger.configuration.user_information
-          new_body = []
-          replace  = replacement(env['honeybadger.error_id'])
-          body.each do |chunk|
-            new_body << chunk.gsub("<!-- HONEYBADGER ERROR -->", replace)
-          end
-          body.close if body.respond_to?(:close)
-          headers['Content-Length'] = new_body.reduce(0) { |a,e| a += e.bytesize }.to_s
-          body = new_body
-        end
-        [status, headers, body]
-      end
-    end
-  end
-end

data/spec/honeybadger/dependency_spec.rb

@@ -1,134 +0,0 @@
-require 'spec_helper'
-
-describe Honeybadger::Dependency do
-  let(:dependency) { Honeybadger::Dependency.new }
-  subject          { dependency }
-
-  before { Honeybadger::Dependency.stub(:instances).and_return([]) }
-
-  describe ".register" do
-    it "returns a new dependency" do
-      instance = double()
-      Honeybadger::Dependency.stub(:new).and_return(instance)
-      expect(Honeybadger::Dependency.register {}).to eq [instance]
-    end
-
-    it "registers a new dependency" do
-      expect { Honeybadger::Dependency.register {} }.to change(described_class, :instances).from([]).to([kind_of(Honeybadger::Dependency)])
-    end
-  end
-
-  describe ".inject!" do
-    it "injects all satisfied instances" do
-      Honeybadger::Dependency.instances.replace([mock_dependency, mock_dependency])
-      Honeybadger::Dependency.inject!
-    end
-
-    it "skips all unsatisfied instances" do
-      Honeybadger::Dependency.instances.replace([mock_dependency(false), mock_dependency(false)])
-      Honeybadger::Dependency.inject!
-    end
-  end
-
-  describe "#requirement" do
-    let(:block) { Proc.new {} }
-
-    it "returns and Array of requirements" do
-      expect(subject.requirement(&block)).to eq [block]
-    end
-
-    it "registers a new requirement" do
-      expect { subject.requirement(&block) }.to change(subject, :requirements).from([]).to([block])
-    end
-  end
-
-  describe "#injection" do
-    let(:block) { Proc.new {} }
-
-    it "returns an Array of injections" do
-      expect(subject.injection(&block)).to eq [block]
-    end
-
-    it "registers a new injection" do
-      expect { subject.injection(&block) }.to change(subject, :injections).from([]).to([block])
-    end
-  end
-
-  describe "#ok?" do
-    subject { dependency.ok? }
-
-    context "when not injected yet" do
-      it { should be_true }
-    end
-
-    context "when already injected" do
-      before { dependency.inject! }
-
-      it { should be_false }
-    end
-
-    context "all requirements are met" do
-      before do
-        3.times { dependency.requirement { true } }
-      end
-    end
-
-    context "some requirements fail" do
-      before do
-        3.times { dependency.requirement { true } }
-        dependency.requirement { false }
-      end
-
-      it { should be_false }
-    end
-
-    context "some requirements error" do
-      before do
-        dependency.requirement { true }
-        dependency.requirement { fail 'oops!' }
-      end
-
-      it { should be_false }
-
-      it "logs the failure" do
-        Honeybadger.should_receive(:write_verbose_log).with(/oops!/, :error).once
-        dependency.ok?
-      end
-    end
-  end
-
-  describe "#inject!" do
-    it "calls injections" do
-      dependency.injections.replace([mock_injection, mock_injection])
-      dependency.inject!
-    end
-
-    context "some injections fail" do
-      before do
-        failing_injection = Proc.new { fail 'oh noes!' }
-        dependency.injections.replace([mock_injection, failing_injection, mock_injection(false)])
-      end
-
-      it "halts injection silently" do
-        expect { dependency.inject! }.not_to raise_error
-      end
-
-      it "logs the failure" do
-        Honeybadger.should_receive(:write_verbose_log).with(/oh noes!/, :error).once
-        dependency.inject!
-      end
-
-      it "marks the dependency as injected" do
-        expect { dependency.inject!}.to change(dependency, :injected?).from(false).to(true)
-      end
-    end
-  end
-
-  def mock_dependency(ok = true)
-    double(:ok? => ok).tap { |d| d.send(ok ? :should_receive : :should_not_receive, :inject!) }
-  end
-
-  def mock_injection(positive = true)
-    double().tap { |d| d.send(positive ? :should_receive : :should_not_receive, :call) }
-  end
-end

data/spec/honeybadger/exception_extensions_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Exception, :unless => defined?(BindingOfCaller) do
-  should { respond_to :__honeybadger_bindings_stack }
-  its(:__honeybadger_bindings_stack) { should eq([]) }
-end
-
-describe Exception, :if => defined?(BindingOfCaller) do
-  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/exception_extensions.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

data/spec/honeybadger/integrations/delayed_job_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe "DelayedJob Dependency" do
-  before do
-    Honeybadger::Dependency.reset!
-  end
-
-  context "when delayed_job is not installed" do
-    it "fails quietly" do
-      expect { Honeybadger::Dependency.inject! }.not_to raise_error
-    end
-  end
-
-  context "when delayed_job is installed" do
-    let(:plugins_array) { [] }
-    let(:plugin_class) do
-      Class.new do
-        def self.callbacks(&block)
-        end
-      end
-    end
-
-    before do
-      Object.const_set(:Delayed, Module.new)
-      ::Delayed.const_set(:Plugins, Module.new)
-      ::Delayed::Plugins.const_set(:Plugin, plugin_class)
-      ::Delayed.const_set(:Worker, double(:plugins => plugins_array))
-    end
-
-    after { Object.send(:remove_const, :Delayed) }
-
-    it "adds the plugin to DelayedJob" do
-      Honeybadger::Dependency.inject!
-      expect(plugins_array).to include(Honeybadger::Integrations::DelayedJob::Plugin)
-    end
-
-    context "and delayed_job_honeybadger is installed" do
-      before do
-        ::Delayed::Plugins.const_set(:Honeybadger, Class.new(plugin_class))
-      end
-
-      it "warns the user of the conflict" do
-        Honeybadger.should_receive(:write_verbose_log).with(/Support for Delayed Job has been moved/, :warn).once
-        Honeybadger::Dependency.inject!
-      end
-    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,29 +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
-      double('fake thor')
-    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/payload_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Honeybadger::Payload do
-  its(:max_depth) { should eq 20 }
-
-  context "when max_depth option is passed to #initialize" do
-    subject { described_class.new({}, :max_depth => 5) }
-    its(:max_depth) { should eq 5 }
-
-    context "when initialized with a bad object" do
-      it "raises ArgumentError" do
-        expect { described_class.new([], :max_depth => 5) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "#sanitize" do
-    let(:deep_hash) { {}.tap {|h| 30.times.each {|i| h = h[i.to_s] = {:string => 'string'} }} }
-    let(:expected_hash) { {}.tap {|h| max_depth.times.each {|i| h = h[i.to_s] = {:string => 'string'} }} }
-    let(:sanitized_hash) { described_class.new(deep_hash, :max_depth => max_depth) }
-    let(:max_depth) { 10 }
-
-    it "truncates nested hashes to max_depth" do
-      expect(sanitized_hash).to eq(expected_hash)
-    end
-  end
-end