honeybadger 1.16.7 → 2.0.0.beta.1

data/spec/honeybadger/notifier_spec.rb

@@ -1,328 +0,0 @@
-require 'spec_helper'
-
-describe 'Honeybadger' do
-  class OriginalException < Exception
-  end
-
-  class ContinuedException < Exception
-  end
-
-  def assert_sends(notice, notice_args)
-    Honeybadger::Notice.should_receive(:new).with(hash_including(notice_args))
-    Honeybadger.sender.should_receive(:send_to_honeybadger).with(notice)
-  end
-
-  def set_public_env
-    Honeybadger.configure { |config| config.environment_name = 'production' }
-  end
-
-  def set_development_env
-    Honeybadger.configure { |config| config.environment_name = 'development' }
-  end
-
-  before(:each) { reset_config }
-
-  describe "#ping" do
-    let(:config) { Honeybadger::Configuration.new }
-    let(:sender) { double() }
-
-    let(:invoke_subject) { Honeybadger.ping(config) }
-    subject { invoke_subject }
-
-    before do
-      config.framework = 'Rails 4.1.0'
-      config.environment_name = 'production'
-      config.hostname = 'twix'
-      stub_const('Honeybadger::VERSION', '1.11.0')
-
-      Honeybadger.stub(:sender).and_return(sender)
-    end
-
-    context "configuration is public" do
-      before { config.stub(:public?).and_return(true) }
-
-      it "pings the sender" do
-        sender.should_receive(:ping).with(hash_including(:version => '1.11.0', :framework => 'Rails 4.1.0', :environment => 'production', :hostname => 'twix'))
-        invoke_subject
-      end
-
-      context "result is truthy" do
-        before { sender.should_receive(:ping).and_return(result) }
-        before { Honeybadger.stub(:write_verbose_log) }
-
-        context "result does not contain features" do
-          let(:result) { {} }
-          it { should be_nil }
-          specify { expect { subject }.not_to change(config, :features) }
-        end
-
-        context "result contains features" do
-          let(:result) { {'features' => {'notices' => true, 'metrics' => true}} }
-          it { should eq result['features'] }
-          specify { expect { subject }.to change(config, :features).to(result['features']) }
-        end
-
-        context "metrics are disabled by service" do
-          let(:result) { {'features' => {'metrics' => false}} }
-          specify { expect { invoke_subject }.to change(config, :metrics).to(false) }
-        end
-
-        context "traces are disabled by service" do
-          let(:result) { {'features' => {'traces' => false}} }
-          specify { expect { invoke_subject }.to change(config, :traces).to(false) }
-        end
-      end
-
-      context "result is falsey" do
-        before { sender.should_receive(:ping) }
-        it { should be_nil }
-        specify { expect { invoke_subject }.not_to change(config, :features) }
-      end
-    end
-
-    context "configuration is not public" do
-      before { config.stub(:public?).and_return(false) }
-      it { should be_nil }
-
-      it "doesn't attempt to ping sender" do
-        sender.should_not_receive(:ping)
-        invoke_subject
-      end
-    end
-  end
-
-  it "yields and save a configuration when configuring" do
-    yielded_configuration = nil
-    Honeybadger.configure do |config|
-      yielded_configuration = config
-    end
-
-    expect(yielded_configuration).to be_a Honeybadger::Configuration
-    expect(yielded_configuration).to be Honeybadger.configuration
-  end
-
-  it "does not remove existing config options when configuring twice" do
-    first_config = nil
-    Honeybadger.configure do |config|
-      first_config = config
-    end
-    Honeybadger.configure do |config|
-      expect(config).to be first_config
-    end
-  end
-
-  it "configures the sender" do
-    sender = stub_sender
-    Honeybadger::Sender.stub(:new => sender)
-
-    Honeybadger.configure { |yielded_config| Honeybadger::Sender.should_receive(:new).with(yielded_config) }
-    expect(Honeybadger.sender).to be sender
-  end
-
-  it "creates and send a notice asynchronously" do
-    set_public_env
-    notice = stub_notice!
-    notice_args = { :error_message => 'uh oh' }
-
-    async_expectation = double(:received => true)
-    async_handler = Proc.new do |n|
-      async_expectation.received
-      n.deliver
-    end
-
-    Honeybadger.configure do |config|
-      config.async = async_handler
-    end
-
-    stub_sender!
-
-    async_expectation.should_receive(:received)
-    assert_sends(notice, notice_args)
-
-    Honeybadger.notify(notice_args)
-  end
-
-  it "creates and send a notice for an exception" do
-    set_public_env
-    exception = build_exception
-    stub_sender!
-    notice = stub_notice!
-
-    assert_sends notice, :exception => exception
-    Honeybadger.notify(exception)
-  end
-
-  it "creates and send a notice for a hash" do
-    set_public_env
-    notice = stub_notice!
-    notice_args = { :error_message => 'uh oh' }
-    stub_sender!
-
-    assert_sends(notice, notice_args)
-    Honeybadger.notify(notice_args)
-  end
-
-  it "does not pass the hash as an exception when sending a notice for it" do
-    set_public_env
-    stub_notice!
-    notice_args = { :error_message => 'uh oh' }
-    stub_sender!
-
-    Honeybadger::Notice.should_receive(:new).with(hash_excluding(:exception))
-    Honeybadger.notify(notice_args)
-  end
-
-  it "creates and send a notice for an exception that responds to to_hash" do
-    set_public_env
-    exception = build_exception
-    notice = stub_notice!
-    notice_args = { :error_message => 'uh oh' }
-    exception.stub(:to_hash).and_return(notice_args)
-    stub_sender!
-
-    assert_sends(notice, notice_args.merge(:exception => exception))
-    Honeybadger.notify(exception)
-  end
-
-  it "creates and sent a notice for an exception and hash" do
-    set_public_env
-    exception = build_exception
-    notice = stub_notice!
-    notice_args = { :error_message => 'uh oh' }
-    stub_sender!
-
-    assert_sends(notice, notice_args.merge(:exception => exception))
-    Honeybadger.notify(exception, notice_args)
-  end
-
-  it "does not create a notice in a development environment" do
-    set_development_env
-    sender = stub_sender!
-
-    sender.should_receive(:send_to_honeybadger).never
-
-    Honeybadger.notify(build_exception)
-    Honeybadger.notify_or_ignore(build_exception)
-  end
-
-  it "does not deliver an ignored exception when notifying implicitly" do
-    set_public_env
-    exception = build_exception
-    sender = stub_sender!
-    notice = stub_notice!
-    notice.stub(:ignore? => true)
-
-    sender.should_receive(:send_to_honeybadger).never
-
-    Honeybadger.notify_or_ignore(exception)
-  end
-
-  it "delivers an ignored exception when notifying manually" do
-    set_public_env
-    exception = build_exception
-    stub_sender!
-    notice = stub_notice!
-    notice.stub(:ignore? => true)
-
-    assert_sends(notice, :exception => exception)
-    Honeybadger.notify(exception)
-  end
-
-  it "passes config to created notices" do
-    exception = build_exception
-    config_opts = { 'one' => 'two', 'three' => 'four' }
-    stub_notice!
-    stub_sender!
-    Honeybadger.configuration = double('config', :merge => config_opts, :public? => true, :async? => false, :unwrap_exceptions => false)
-
-    Honeybadger::Notice.should_receive(:new).with(hash_including(config_opts))
-    Honeybadger.notify(exception)
-  end
-
-  context "building notice JSON for an exception" do
-    before(:each) do
-      @params    = { :controller => "users", :action => "create" }
-      @exception = build_exception
-      @hash      = Honeybadger.build_lookup_hash_for(@exception, @params)
-    end
-
-    it "sets action" do
-      expect(@hash[:action]).to eq @params[:action]
-    end
-
-    it "sets controller" do
-      expect(@hash[:component]).to eq @params[:controller]
-    end
-
-    it "sets line number" do
-      expect(@hash[:line_number]).to match /\d+/
-    end
-
-    it "sets file" do
-      expect(@hash[:file]).to match /honeybadger\/rack_test\.rb$/
-    end
-
-    it "sets environment_name to production" do
-      expect(@hash[:environment_name]).to eq 'production'
-    end
-
-    it "sets error class" do
-      expect(@hash[:error_class]).to eq @exception.class.to_s
-    end
-
-    it "does not set file or line number with no backtrace" do
-      @exception.stub(:backtrace).and_return([])
-
-      @hash = Honeybadger.build_lookup_hash_for(@exception)
-
-      @hash[:line_number].should be_nil
-      @hash[:file].should be_nil
-    end
-
-    it "does not set action or controller when not provided" do
-      @hash = Honeybadger.build_lookup_hash_for(@exception)
-
-      @hash[:action].should be_nil
-      @hash[:controller].should be_nil
-    end
-
-    context "when an exception that provides #original_exception is raised" do
-      before(:each) do
-        @exception.stub(:original_exception).and_return(begin
-          raise OriginalException.new
-        rescue Exception => e
-          e
-        end)
-      end
-
-      it "unwraps exceptions that provide #original_exception" do
-        @hash = Honeybadger.build_lookup_hash_for(@exception)
-        expect(@hash[:error_class]).to eq "OriginalException"
-      end
-
-      context "but unwrapping exceptions is disabled" do
-        before { Honeybadger.configuration.unwrap_exceptions = false }
-
-        it "doesn't unwrap the exception" do
-          @hash = Honeybadger.build_lookup_hash_for(@exception)
-          expect(@hash[:error_class]).not_to eq "OriginalException"
-        end
-      end
-    end
-
-    context "when an exception that provides #continued_exception is raised" do
-      before(:each) do
-        @exception.stub(:continued_exception).and_return(begin
-          raise ContinuedException.new
-        rescue Exception => e
-          e
-        end)
-      end
-
-      it "unwraps exceptions that provide #continued_exception" do
-        @hash = Honeybadger.build_lookup_hash_for(@exception)
-        expect(@hash[:error_class]).to eq "ContinuedException"
-      end
-    end
-  end
-end

data/spec/honeybadger/payload_spec.rb

@@ -1,162 +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] = (i < max_depth-1 ? {:string => 'string'} : '[max depth reached]') }} }
-    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['0']).to eq(expected_hash['0'])
-    end
-
-    it "does not allow infinite recursion" do
-      hash = {:a => :a}
-      hash[:hash] = hash
-      payload = described_class.new(:request => {:params => hash})
-      expect(payload.request[:params][:hash]).to eq "[possible infinite recursion halted]"
-    end
-
-    it "converts unserializable objects to strings" do
-      assert_serializes(:request, :parameters)
-      assert_serializes(:request, :cgi_data)
-      assert_serializes(:request, :session_data)
-      assert_serializes(:request, :local_variables)
-    end
-
-    it "ensures #to_hash is called on objects that support it" do
-      expect { described_class.new(:session => { :object => double(:to_hash => {}) }) }.not_to raise_error
-    end
-
-    it "ensures #to_ary is called on objects that support it" do
-      expect { described_class.new(:session => { :object => double(:to_ary => {}) }) }.not_to raise_error
-    end
-  end
-
-  it "filters parameters" do
-    assert_filters_request(:params)
-  end
-
-  it "filters cgi data" do
-    assert_filters_request(:cgi_data)
-  end
-
-  it "filters session" do
-    assert_filters_request(:session)
-  end
-
-  it "filters local_variables" do
-    assert_filters_request(:local_variables)
-  end
-
-  context 'filtered parameters in query string' do
-    let(:params_filters) { [:foo, :bar] }
-
-    describe '#url' do
-      subject { described_class.new({:request => {:url => 'https://www.honeybadger.io/?foo=1&bar=2&baz=3'}}, :filters => params_filters).request[:url] }
-
-      it 'filters query' do
-        expect(subject).to eq 'https://www.honeybadger.io/?foo=[FILTERED]&bar=[FILTERED]&baz=3'
-      end
-    end
-
-    describe '#cgi_data' do
-      let(:cgi_data) { { 'QUERY_STRING' => 'foo=1&bar=2&baz=3', 'ORIGINAL_FULLPATH' => '/?foo=1&bar=2&baz=3' } }
-
-      subject { described_class.new({:request => {:cgi_data => cgi_data}}, :filters => params_filters).request[:cgi_data] }
-
-      it 'filters QUERY_STRING key' do
-        expect(subject['QUERY_STRING']).to eq 'foo=[FILTERED]&bar=[FILTERED]&baz=3'
-      end
-
-      it 'filters ORIGINAL_FULLPATH key' do
-        expect(subject['ORIGINAL_FULLPATH']).to eq '/?foo=[FILTERED]&bar=[FILTERED]&baz=3'
-      end
-    end
-  end
-
-  describe '#filter_url!' do
-    subject { described_class.new.send(:filter_url!, url) }
-
-    context 'malformed query' do
-      let(:url) { 'https://www.honeybadger.io/?foobar12' }
-      it { should eq url }
-    end
-
-    context 'no query' do
-      let(:url) { 'https://www.honeybadger.io' }
-      it { should eq url }
-    end
-
-    context 'malformed url' do
-      let(:url) { 'http s ! honeybadger' }
-      before { expect { URI.parse(url) }.to raise_error }
-      it { should eq url }
-    end
-
-    context 'complex url' do
-      let(:url) { 'https://foo:bar@www.honeybadger.io:123/asdf/?foo=1&bar=2&baz=3' }
-      it { should eq url }
-    end
-  end
-
-  def assert_serializes(*keys)
-    [File.open(__FILE__), Proc.new { puts "boo!" }, Module.new].each do |object|
-      hash = {
-        :strange_object => object,
-        :sub_hash => {
-          :sub_object => object
-        },
-        :array => [object]
-      }
-
-      payload_keys = keys.dup
-      last_key = payload_keys.pop
-      payload = described_class.new(payload_keys.reverse.reduce({last_key => hash}) { |a,k| {k => a} })
-
-      first_key = keys.shift
-      hash = keys.reduce(payload[first_key]) {|a,k| a[k] }
-
-      expect(hash[:strange_object]).to eq object.to_s # objects should be serialized
-      expect(hash[:sub_hash]).to be_a Hash # subhashes should be kept
-      expect(hash[:sub_hash][:sub_object]).to eq object.to_s # subhash members should be serialized
-      expect(hash[:array]).to be_a Array # arrays should be kept
-      expect(hash[:array].first).to eq object.to_s # array members should be serialized
-    end
-  end
-
-  def assert_filters_request(attribute)
-    filters  = ["abc", :def, /private/, /^foo_.*$/]
-    original = { 'abc' => "123", 'def' => "456", 'ghi' => "789", 'nested' => { 'abc' => '100' },
-      'something_with_abc' => 'match the entire string', 'private_param' => 'prra',
-      'foo_param' => 'bar', 'not_foo_param' => 'baz', 'nested_foo' => { 'foo_nested' => 'bla'} }
-    filtered = { 'abc'    => "[FILTERED]",
-                 'def'    => "[FILTERED]",
-                 'something_with_abc' => "match the entire string",
-                 'ghi'    => "789",
-                 'nested' => { 'abc' => '[FILTERED]' },
-                 'private_param' => '[FILTERED]',
-                 'foo_param' => '[FILTERED]',
-                 'not_foo_param' => 'baz',
-                 'nested_foo' => { 'foo_nested' => '[FILTERED]'}
-    }
-
-    payload = described_class.new({:request => {attribute => original}}, {:filters => filters})
-
-    expect(payload.request[attribute]).to eq filtered
-  end
-end