honeybadger 1.0.0

data/script/integration_test.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require 'logger'
+require 'fileutils'
+
+RAILS_ENV = "production"
+RAILS_ROOT = FileUtils.pwd
+RAILS_DEFAULT_LOGGER = Logger.new(STDOUT)
+
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'honeybadger'
+require 'rails/init'
+
+fail "Please supply an API Key as the first argument" if ARGV.empty?
+
+host = ARGV[1]
+host ||= "api.honeybadger.io"
+
+secure = (ARGV[2] == "secure")
+
+exception = begin
+              raise "Testing honeybadger notifier with secure = #{secure}. If you can see this, it works."
+            rescue => foo
+              foo
+            end
+
+Honeybadger.configure do |config|
+  config.secure  = secure
+  config.host    = host
+  config.api_key = ARGV.first
+end
+puts "Configuration:"
+Honeybadger.configuration.to_hash.each do |key, value|
+  puts sprintf("%25s: %s", key.to_s, value.inspect.slice(0, 55))
+end
+puts "Sending #{secure ? "" : "in"}secure notification to project with key #{ARGV.first}"
+Honeybadger.notify(exception)
+

data/test/test_helper.rb

@@ -0,0 +1,143 @@
+require 'test/unit'
+
+require 'bundler/setup'
+
+require 'mocha'
+require 'shoulda'
+require 'bourne'
+require 'rack'
+
+require 'action_controller'
+require 'action_controller/test_process'
+require 'active_record'
+require 'active_support'
+
+require 'honeybadger'
+
+class BacktracedException < Exception
+  attr_accessor :backtrace
+  def initialize(opts)
+    @backtrace = opts[:backtrace]
+  end
+  def set_backtrace(bt)
+    @backtrace = bt
+  end
+end
+
+module DefinesConstants
+  def setup
+    @defined_constants = []
+  end
+
+  def teardown
+    @defined_constants.each do |constant|
+      Object.__send__(:remove_const, constant)
+    end
+  end
+
+  def define_constant(name, value)
+    Object.const_set(name, value)
+    @defined_constants << name
+  end
+end
+
+class CollectingSender
+  attr_reader :collected
+
+  def initialize
+    @collected = []
+  end
+
+  def send_to_honeybadger(data)
+    @collected << data
+  end
+end
+
+module Honeybadger
+  class UnitTest < Test::Unit::TestCase
+    def assert_no_difference(expression, message = nil, &block)
+      assert_difference expression, 0, message, &block
+    end
+
+    def stub_sender
+      stub('sender', :send_to_honeybadger => nil)
+    end
+
+    def stub_sender!
+      Honeybadger.sender = stub_sender
+    end
+
+    def stub_notice
+      stub('notice', :to_json => 'some yaml', :ignore? => false)
+    end
+
+    def stub_notice!
+       stub_notice.tap do |notice|
+        Honeybadger::Notice.stubs(:new => notice)
+      end
+    end
+
+    def reset_config
+      Honeybadger.configuration = nil
+      Honeybadger.configure do |config|
+        config.api_key = 'abc123'
+      end
+    end
+
+    def build_notice_data(exception = nil)
+      exception ||= build_exception
+      {
+        :api_key       => 'abc123',
+        :error_class   => exception.class.name,
+        :error_message => "#{exception.class.name}: #{exception.message}",
+        :backtrace     => exception.backtrace,
+        :environment   => { 'PATH' => '/bin', 'REQUEST_URI' => '/users/1' },
+        :request       => {
+          :params     => { 'controller' => 'users', 'action' => 'show', 'id' => '1' },
+          :rails_root => '/path/to/application',
+          :url        => "http://test.host/users/1"
+        },
+        :session       => {
+          :key  => '123abc',
+          :data => { 'user_id' => '5', 'flash' => { 'notice' => 'Logged in successfully' } }
+        }
+      }
+    end
+
+    def build_exception(opts = {})
+      backtrace = ["test/honeybadger/rack_test.rb:15:in `build_exception'",
+                   "test/honeybadger/rack_test.rb:52:in `test_delivers_exception_from_rack'",
+                   "/Users/josh/Developer/.rvm/gems/ruby-1.9.3-p0/gems/mocha-0.10.5/lib/mocha/integration/mini_test/version_230_to_262.rb:28:in `run'"]
+      opts = { :backtrace => backtrace }.merge(opts)
+      BacktracedException.new(opts)
+    end
+
+    def assert_array_starts_with(expected, actual)
+      assert_respond_to actual, :to_ary
+      array = actual.to_ary.reverse
+      expected.reverse.each_with_index do |value, i|
+        assert_equal value, array[i]
+      end
+    end
+
+    def assert_logged(expected)
+      assert_received(Honeybadger, :write_verbose_log) do |expect|
+        expect.with {|actual| actual =~ expected }
+      end
+    end
+
+    def assert_not_logged(expected)
+      assert_received(Honeybadger, :write_verbose_log) do |expect|
+        expect.with {|actual| actual =~ expected }.never
+      end
+    end
+
+    def assert_caught_and_sent
+      assert !Honeybadger.sender.collected.empty?
+    end
+
+    def assert_caught_and_not_sent
+      assert Honeybadger.sender.collected.empty?
+    end
+  end
+end

data/test/unit/backtrace_test.rb

@@ -0,0 +1,180 @@
+require 'test_helper'
+
+class BacktraceTest < Honeybadger::UnitTest
+  should "parse a backtrace into lines" do
+    array = [
+      "app/models/user.rb:13:in `magic'",
+      "app/controllers/users_controller.rb:8:in `index'"
+    ]
+
+    backtrace = Honeybadger::Backtrace.parse(array)
+
+    line = backtrace.lines.first
+    assert_equal '13', line.number
+    assert_equal 'app/models/user.rb', line.file
+    assert_equal 'magic', line.method
+
+    line = backtrace.lines.last
+    assert_equal '8', line.number
+    assert_equal 'app/controllers/users_controller.rb', line.file
+    assert_equal 'index', line.method
+  end
+
+  should "parse a windows backtrace into lines" do
+    array = [
+      "C:/Program Files/Server/app/models/user.rb:13:in `magic'",
+      "C:/Program Files/Server/app/controllers/users_controller.rb:8:in `index'"
+    ]
+
+    backtrace = Honeybadger::Backtrace.parse(array)
+
+    line = backtrace.lines.first
+    assert_equal '13', line.number
+    assert_equal 'C:/Program Files/Server/app/models/user.rb', line.file
+    assert_equal 'magic', line.method
+
+    line = backtrace.lines.last
+    assert_equal '8', line.number
+    assert_equal 'C:/Program Files/Server/app/controllers/users_controller.rb', line.file
+    assert_equal 'index', line.method
+  end
+
+  should "be equal with equal lines" do
+    one = build_backtrace_array
+    two = one.dup
+
+    assert_equal Honeybadger::Backtrace.parse(one), Honeybadger::Backtrace.parse(two)
+  end
+
+  should "parse massive one-line exceptions into multiple lines" do
+    original_backtrace = Honeybadger::Backtrace.
+      parse(["one:1:in `one'\n   two:2:in `two'\n      three:3:in `three`"])
+    expected_backtrace = Honeybadger::Backtrace.
+      parse(["one:1:in `one'", "two:2:in `two'", "three:3:in `three`"])
+
+    assert_equal expected_backtrace, original_backtrace
+  end
+
+  context "with a project root" do
+    setup do
+      @project_root = '/some/path'
+      Honeybadger.configure {|config| config.project_root = @project_root }
+    end
+
+    teardown do
+      reset_config
+    end
+
+    should "filter out the project root" do
+      backtrace_with_root = Honeybadger::Backtrace.parse(
+        ["#{@project_root}/app/models/user.rb:7:in `latest'",
+         "#{@project_root}/app/controllers/users_controller.rb:13:in `index'",
+         "/lib/something.rb:41:in `open'"],
+         :filters => default_filters)
+         backtrace_without_root = Honeybadger::Backtrace.parse(
+           ["[PROJECT_ROOT]/app/models/user.rb:7:in `latest'",
+            "[PROJECT_ROOT]/app/controllers/users_controller.rb:13:in `index'",
+            "/lib/something.rb:41:in `open'"])
+
+            assert_equal backtrace_without_root, backtrace_with_root
+    end
+  end
+
+  context "with a project root equals to a part of file name" do
+    setup do
+      # Heroku-like
+      @project_root = '/app'
+      Honeybadger.configure {|config| config.project_root = @project_root }
+    end
+
+    teardown do
+      reset_config
+    end
+
+    should "filter out the project root" do
+      backtrace_with_root = Honeybadger::Backtrace.parse(
+        ["#{@project_root}/app/models/user.rb:7:in `latest'",
+         "#{@project_root}/app/controllers/users_controller.rb:13:in `index'",
+         "/lib/something.rb:41:in `open'"],
+         :filters => default_filters)
+         backtrace_without_root = Honeybadger::Backtrace.parse(
+           ["[PROJECT_ROOT]/app/models/user.rb:7:in `latest'",
+            "[PROJECT_ROOT]/app/controllers/users_controller.rb:13:in `index'",
+            "/lib/something.rb:41:in `open'"])
+
+            assert_equal backtrace_without_root, backtrace_with_root
+    end
+  end
+
+  context "with a blank project root" do
+    setup do
+      Honeybadger.configure {|config| config.project_root = '' }
+    end
+
+    teardown do
+      reset_config
+    end
+
+    should "not filter line numbers with respect to any project root" do
+      backtrace = ["/app/models/user.rb:7:in `latest'",
+                   "/app/controllers/users_controller.rb:13:in `index'",
+                   "/lib/something.rb:41:in `open'"]
+
+      backtrace_with_root =
+        Honeybadger::Backtrace.parse(backtrace, :filters => default_filters)
+
+      backtrace_without_root =
+        Honeybadger::Backtrace.parse(backtrace)
+
+      assert_equal backtrace_without_root, backtrace_with_root
+    end
+  end
+
+  should "remove notifier trace" do
+    inside_notifier  = ['lib/honeybadger.rb:13:in `voodoo`']
+    outside_notifier = ['users_controller:8:in `index`']
+
+    without_inside = Honeybadger::Backtrace.parse(outside_notifier)
+    with_inside    = Honeybadger::Backtrace.parse(inside_notifier + outside_notifier,
+                                                  :filters => default_filters)
+
+    assert_equal without_inside, with_inside
+  end
+
+  should "run filters on the backtrace" do
+    filters = [lambda { |line| line.sub('foo', 'bar') }]
+    input = Honeybadger::Backtrace.parse(["foo:13:in `one'", "baz:14:in `two'"],
+                                         :filters => filters)
+    expected = Honeybadger::Backtrace.parse(["bar:13:in `one'", "baz:14:in `two'"])
+    assert_equal expected, input
+  end
+
+  should "alias #to_ary as #to_a" do
+    backtrace = Honeybadger::Backtrace.parse(build_backtrace_array)
+
+    assert_equal backtrace.to_a, backtrace.to_ary
+  end
+
+  should "generate json from to_array template" do
+    backtrace = Honeybadger::Backtrace.parse(build_backtrace_array)
+    array = [{'foo' => 'bar'}]
+    backtrace.expects(:to_ary).once.returns(array)
+    json = backtrace.to_json
+
+    payload = nil
+    assert_nothing_raised do
+      payload = JSON.parse(json)
+    end
+
+    assert_equal payload, array
+  end
+
+  def build_backtrace_array
+    ["app/models/user.rb:13:in `magic'",
+     "app/controllers/users_controller.rb:8:in `index'"]
+  end
+
+  def default_filters
+    Honeybadger::Configuration::DEFAULT_BACKTRACE_FILTERS
+  end
+end

data/test/unit/capistrano_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+require 'capistrano/configuration'
+require 'honeybadger/capistrano'
+
+class CapistranoTest < Honeybadger::UnitTest
+  def setup
+    super
+    reset_config
+
+    @configuration = Capistrano::Configuration.new
+    Honeybadger::Capistrano.load_into(@configuration)
+    @configuration.dry_run = true
+  end
+
+  should "define honeybadger:deploy task" do
+    assert_not_nil @configuration.find_task('honeybadger:deploy')
+  end
+
+  should "log when calling honeybadger:deploy task" do
+    @configuration.set(:current_revision, '084505b1c0e0bcf1526e673bb6ac99fbcb18aecc')
+    @configuration.set(:repository, 'repository')
+    @configuration.set(:current_release, '/home/deploy/rails_app/hoptoad')
+    io = StringIO.new
+    logger = Capistrano::Logger.new(:output => io)
+    logger.level = Capistrano::Logger::MAX_LEVEL
+
+    @configuration.logger = logger
+    @configuration.find_and_execute_task('honeybadger:deploy')
+
+    assert io.string.include?('** Notifying Honeybadger of Deploy')
+    assert io.string.include?('** Honeybadger Notification Complete')
+  end
+end

data/test/unit/configuration_test.rb

@@ -0,0 +1,201 @@
+require 'test_helper'
+
+class ConfigurationTest < Honeybadger::UnitTest
+  include DefinesConstants
+
+  should "provide default values" do
+    assert_config_default :proxy_host,          nil
+    assert_config_default :proxy_port,          nil
+    assert_config_default :proxy_user,          nil
+    assert_config_default :proxy_pass,          nil
+    assert_config_default :project_root,        nil
+    assert_config_default :environment_name,    nil
+    assert_config_default :logger,              nil
+    assert_config_default :notifier_version,    Honeybadger::VERSION
+    assert_config_default :notifier_name,       'Honeybadger Notifier'
+    assert_config_default :notifier_url,        'https://github.com/honeybadger/honeybadger'
+    assert_config_default :secure,              false
+    assert_config_default :host,                'api.honeybadger.io'
+    assert_config_default :http_open_timeout,   2
+    assert_config_default :http_read_timeout,   5
+    assert_config_default :ignore_by_filters,   []
+    assert_config_default :ignore_user_agent,   []
+    assert_config_default :params_filters,
+                          Honeybadger::Configuration::DEFAULT_PARAMS_FILTERS
+    assert_config_default :backtrace_filters,
+                          Honeybadger::Configuration::DEFAULT_BACKTRACE_FILTERS
+    assert_config_default :ignore,
+                          Honeybadger::Configuration::IGNORE_DEFAULT
+    assert_config_default :framework, 'Standalone'
+  end
+
+  should "provide default values for secure connections" do
+    config = Honeybadger::Configuration.new
+    config.secure = true
+    assert_equal 443, config.port
+    assert_equal 'https', config.protocol
+  end
+
+  should "provide default values for insecure connections" do
+    config = Honeybadger::Configuration.new
+    config.secure = false
+    assert_equal 80, config.port
+    assert_equal 'http', config.protocol
+  end
+
+  should "not cache inferred ports" do
+    config = Honeybadger::Configuration.new
+    config.secure = false
+    config.port
+    config.secure = true
+    assert_equal 443, config.port
+  end
+
+  should "allow values to be overwritten" do
+    assert_config_overridable :proxy_host
+    assert_config_overridable :proxy_port
+    assert_config_overridable :proxy_user
+    assert_config_overridable :proxy_pass
+    assert_config_overridable :secure
+    assert_config_overridable :host
+    assert_config_overridable :port
+    assert_config_overridable :http_open_timeout
+    assert_config_overridable :http_read_timeout
+    assert_config_overridable :project_root
+    assert_config_overridable :notifier_version
+    assert_config_overridable :notifier_name
+    assert_config_overridable :notifier_url
+    assert_config_overridable :environment_name
+    assert_config_overridable :logger
+  end
+
+  should "have an api key" do
+    assert_config_overridable :api_key
+  end
+
+  should "act like a hash" do
+    config = Honeybadger::Configuration.new
+    hash = config.to_hash
+    [:api_key, :backtrace_filters, :development_environments,
+     :environment_name, :host, :http_open_timeout,
+     :http_read_timeout, :ignore, :ignore_by_filters, :ignore_user_agent,
+     :notifier_name, :notifier_url, :notifier_version, :params_filters,
+     :project_root, :port, :protocol, :proxy_host, :proxy_pass, :proxy_port,
+     :proxy_user, :secure].each do |option|
+      assert_equal config[option], hash[option], "Wrong value for #{option}"
+    end
+  end
+
+  should "be mergable" do
+    config = Honeybadger::Configuration.new
+    hash = config.to_hash
+    assert_equal hash.merge(:key => 'value'), config.merge(:key => 'value')
+  end
+
+  should "allow param filters to be appended" do
+    assert_appends_value :params_filters
+  end
+
+  should "allow ignored user agents to be appended" do
+    assert_appends_value :ignore_user_agent
+  end
+
+  should "allow backtrace filters to be appended" do
+    assert_appends_value(:backtrace_filters) do |config|
+      new_filter = lambda {}
+      config.filter_backtrace(&new_filter)
+      new_filter
+    end
+  end
+
+  should "allow ignore by filters to be appended" do
+    assert_appends_value(:ignore_by_filters) do |config|
+      new_filter = lambda {}
+      config.ignore_by_filter(&new_filter)
+      new_filter
+    end
+  end
+
+  should "allow ignored exceptions to be appended" do
+    config = Honeybadger::Configuration.new
+    original_filters = config.ignore.dup
+    new_filter = 'hello'
+    config.ignore << new_filter
+    assert_same_elements original_filters + [new_filter], config.ignore
+  end
+
+  should "allow ignored exceptions to be replaced" do
+    assert_replaces(:ignore, :ignore_only=)
+  end
+
+  should "allow ignored user agents to be replaced" do
+    assert_replaces(:ignore_user_agent, :ignore_user_agent_only=)
+  end
+
+  should "use development and test as development environments by default" do
+    config = Honeybadger::Configuration.new
+    assert_same_elements %w(development test cucumber), config.development_environments
+  end
+
+  should "be public in a public environment" do
+    config = Honeybadger::Configuration.new
+    config.development_environments = %w(development)
+    config.environment_name = 'production'
+    assert config.public?
+  end
+
+  should "not be public in a development environment" do
+    config = Honeybadger::Configuration.new
+    config.development_environments = %w(staging)
+    config.environment_name = 'staging'
+    assert !config.public?
+  end
+
+  should "be public without an environment name" do
+    config = Honeybadger::Configuration.new
+    assert config.public?
+  end
+
+  should "use the assigned logger if set" do
+    config = Honeybadger::Configuration.new
+    config.logger = "CUSTOM LOGGER"
+    assert_equal "CUSTOM LOGGER", config.logger
+  end
+
+  should 'give a new instance if non defined' do
+    Honeybadger.configuration = nil
+    assert_kind_of Honeybadger::Configuration, Honeybadger.configuration
+  end
+
+  def assert_config_default(option, default_value, config = nil)
+    config ||= Honeybadger::Configuration.new
+    assert_equal default_value, config.send(option)
+  end
+
+  def assert_config_overridable(option, value = 'a value')
+    config = Honeybadger::Configuration.new
+    config.send(:"#{option}=", value)
+    assert_equal value, config.send(option)
+  end
+
+  def assert_appends_value(option, &block)
+    config = Honeybadger::Configuration.new
+    original_values = config.send(option).dup
+    block ||= lambda do |config|
+      new_value = 'hello'
+      config.send(option) << new_value
+      new_value
+    end
+    new_value = block.call(config)
+    assert_same_elements original_values + [new_value], config.send(option)
+  end
+
+  def assert_replaces(option, setter)
+    config = Honeybadger::Configuration.new
+    new_value = 'hello'
+    config.send(setter, [new_value])
+    assert_equal [new_value], config.send(option)
+    config.send(setter, new_value)
+    assert_equal [new_value], config.send(option)
+  end
+end