honeybadger 1.0.0

data/test/unit/honeybadger_tasks_test.rb

@@ -0,0 +1,163 @@
+require 'test_helper'
+require 'rubygems'
+
+require File.expand_path('../../../lib/honeybadger_tasks', __FILE__)
+require 'fakeweb'
+
+FakeWeb.allow_net_connect = false
+
+class HoneybadgerTasksTest < Honeybadger::UnitTest
+  def successful_response(body = "")
+    response = Net::HTTPSuccess.new('1.2', '200', 'OK')
+    response.stubs(:body).returns(body)
+    return response
+  end
+
+  def unsuccessful_response(body = "")
+    response = Net::HTTPClientError.new('1.2', '200', 'OK')
+    response.stubs(:body).returns(body)
+    return response
+  end
+
+  context "being quiet" do
+    setup { HoneybadgerTasks.stubs(:puts) }
+
+    context "in a configured project" do
+      setup { Honeybadger.configure { |config| config.api_key = "1234123412341234" } }
+
+      context "on deploy({})" do
+        setup { @output = HoneybadgerTasks.deploy({}) }
+
+        before_should "complain about missing rails env" do
+          HoneybadgerTasks.expects(:puts).with(regexp_matches(/rails environment/i))
+        end
+
+        should "return false" do
+          assert !@output
+        end
+      end
+
+      context "given an optional HTTP proxy and valid options" do
+        setup do
+          @response         = stub("response",    :body => "stub body")
+          @http_proxy       = stub("proxy",       :request => @response)
+          @http_proxy_class = stub("proxy_class", :new => @http_proxy)
+          @post             = stub("post",        :set_form_data => nil)
+
+          @post.stubs(:[]=).with('X-API-Key', '1234123412341234').returns(true)
+
+          Net::HTTP.expects(:Proxy).
+            with(Honeybadger.configuration.proxy_host,
+                 Honeybadger.configuration.proxy_port,
+                 Honeybadger.configuration.proxy_user,
+                 Honeybadger.configuration.proxy_pass).
+                 returns(@http_proxy_class)
+          Net::HTTP::Post.expects(:new).with("/deploys.txt").returns(@post)
+
+          @options    = { :rails_env => "staging", :dry_run => false }
+        end
+
+        context "performing a dry run" do
+          setup { @output = HoneybadgerTasks.deploy(@options.merge(:dry_run => true)) }
+
+          should "return true without performing any actual request" do
+            assert_equal true, @output
+            assert_received(@http_proxy, :request) do |expects|
+              expects.never
+            end
+          end
+        end
+
+        context "on deploy(options)" do
+          setup do
+            @output = HoneybadgerTasks.deploy(@options)
+          end
+
+          before_should "post to http://api.honeybadger.io:80/deploys.txt" do
+            @http_proxy_class.expects(:new).with("api.honeybadger.io", 80).returns(@http_proxy)
+            @post.expects(:set_form_data).with(kind_of(Hash))
+            @http_proxy.expects(:request).with(any_parameters).returns(successful_response)
+          end
+
+          before_should "use send the rails_env param" do
+            @post.expects(:set_form_data).
+              with(has_entries("deploy[rails_env]" => "staging"))
+          end
+
+          [:local_username, :scm_repository, :scm_revision].each do |key|
+            before_should "use send the #{key} param if it's passed in." do
+              @options[key] = "value"
+              @post.expects(:set_form_data).
+                with(has_entries("deploy[#{key}]" => "value"))
+            end
+          end
+
+          before_should "puts the response body on success" do
+            HoneybadgerTasks.expects(:puts).with("body")
+            @http_proxy.expects(:request).with(any_parameters).returns(successful_response('body'))
+          end
+
+          before_should "puts the response body on failure" do
+            HoneybadgerTasks.expects(:puts).with("body")
+            @http_proxy.expects(:request).with(any_parameters).returns(unsuccessful_response('body'))
+          end
+
+          should "return false on failure", :before => lambda {
+            @http_proxy.expects(:request).with(any_parameters).returns(unsuccessful_response('body'))
+          } do
+            assert !@output
+          end
+
+          should "return true on success", :before => lambda {
+            @http_proxy.expects(:request).with(any_parameters).returns(successful_response('body'))
+          } do
+            assert @output
+          end
+        end
+      end
+    end
+
+    context "in a configured project with custom host" do
+      setup do
+        Honeybadger.configure do |config| 
+          config.api_key = "1234123412341234"
+          config.host = "custom.host"
+        end
+      end
+
+      context "on deploy(:rails_env => 'staging')" do
+        setup { @output = HoneybadgerTasks.deploy(:rails_env => "staging") }
+
+        before_should "post to the custom host" do
+          @post             = stub("post",     :set_form_data => nil)
+          @http_proxy       = stub("proxy",    :request => @response)
+
+          @post.stubs(:[]=).with('X-API-Key', '1234123412341234').returns(true)
+
+          @http_proxy_class = stub("proxy_class", :new => @http_proxy)
+          @http_proxy_class.expects(:new).with("custom.host", 80).returns(@http_proxy)
+          Net::HTTP.expects(:Proxy).with(any_parameters).returns(@http_proxy_class)
+          Net::HTTP::Post.expects(:new).with("/deploys.txt").returns(@post)
+          @post.expects(:set_form_data).with(kind_of(Hash))
+          @http_proxy.expects(:request).with(any_parameters).returns(successful_response)
+        end
+      end
+    end
+
+    context "when not configured" do
+      setup { Honeybadger.configure { |config| config.api_key = "" } }
+
+      context "on deploy(:rails_env => 'staging')" do
+        setup { @output = HoneybadgerTasks.deploy(:rails_env => "staging") }
+
+        before_should "complain about missing api key" do
+          HoneybadgerTasks.expects(:puts).with(regexp_matches(/api key/i))
+        end
+
+        should "return false" do
+          assert !@output
+        end
+      end
+    end
+  end
+end

data/test/unit/logger_test.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+
+class LoggerTest < Honeybadger::UnitTest
+  def stub_http(response, body = nil)
+    response.stubs(:body => body) if body
+    @http = stub(:post => response,
+                 :read_timeout= => nil,
+                 :open_timeout= => nil,
+                 :use_ssl= => nil)
+    Net::HTTP.stubs(:new).returns(@http)
+  end
+
+  def send_notice
+    Honeybadger.sender.send_to_honeybadger('data')
+  end
+
+  def stub_verbose_log
+    Honeybadger.stubs(:write_verbose_log)
+  end
+
+  def configure
+    Honeybadger.configure { |config| }
+  end
+
+  should "report that notifier is ready when configured" do
+    stub_verbose_log
+    configure
+    assert_logged /Notifier (.*) ready/
+  end
+
+  should "not report that notifier is ready when internally configured" do
+    stub_verbose_log
+    Honeybadger.configure(true) { |config| }
+    assert_not_logged /.*/
+  end
+
+  should "print environment info a successful notification without a body" do
+    reset_config
+    stub_verbose_log
+    stub_http(Net::HTTPSuccess)
+    send_notice
+    assert_logged /Environment Info:/
+    assert_not_logged /Response from Honeybadger:/
+  end
+
+  should "print environment info on a failed notification without a body" do
+    reset_config
+    stub_verbose_log
+    stub_http(Net::HTTPError)
+    send_notice
+    assert_logged /Environment Info:/
+    assert_not_logged /Response from Honeybadger:/
+  end
+
+  should "print environment info and response on a success with a body" do
+    reset_config
+    stub_verbose_log
+    stub_http(Net::HTTPSuccess, '{}')
+    send_notice
+    assert_logged /Environment Info:/
+    assert_logged /Response from Honeybadger:/
+  end
+
+  should "print environment info and response on a failure with a body" do
+    reset_config
+    stub_verbose_log
+    stub_http(Net::HTTPError, '{}')
+    send_notice
+    assert_logged /Environment Info:/
+    assert_logged /Response from Honeybadger:/
+  end
+end

data/test/unit/notice_test.rb

@@ -0,0 +1,406 @@
+require 'test_helper'
+require 'json'
+
+class NoticeTest < Honeybadger::UnitTest
+  include DefinesConstants
+
+  def configure
+    Honeybadger::Configuration.new.tap do |config|
+      config.api_key = 'abc123def456'
+    end
+  end
+
+  def build_notice(args = {})
+    configuration = args.delete(:configuration) || configure
+    Honeybadger::Notice.new(configuration.merge(args))
+  end
+
+  def stub_request(attrs = {})
+    stub('request', { :parameters  => { 'one' => 'two' },
+                      :protocol    => 'http',
+                      :host        => 'some.host',
+                      :request_uri => '/some/uri',
+                      :session     => { :to_hash => { 'a' => 'b' } },
+                      :env         => { 'three' => 'four' } }.update(attrs))
+  end
+
+  should "generate json from as_json template" do
+    notice = build_notice
+    hash = {'foo' => 'bar'}
+    notice.expects(:as_json).once.returns(hash)
+    json = notice.to_json
+
+    payload = nil
+    assert_nothing_raised do
+      payload = JSON.parse(json)
+    end
+
+    assert_equal payload, hash
+  end
+
+  should "accept a project root" do
+    project_root = '/path/to/project'
+    notice = build_notice(:project_root => project_root)
+    assert_equal project_root, notice.project_root
+  end
+
+  should "accept a component" do
+    assert_equal 'users_controller', build_notice(:component => 'users_controller').controller
+  end
+
+  should "alias the component as controller" do
+    assert_equal 'users_controller', build_notice(:controller => 'users_controller').component
+    assert_equal 'users_controller', build_notice(:component => 'users_controller').controller
+  end
+
+  should "accept a action" do
+    assert_equal 'index', build_notice(:action => 'index').action
+  end
+
+  should "accept a url" do
+    url = 'http://some.host/uri'
+    notice = build_notice(:url => url)
+    assert_equal url, notice.url
+  end
+
+  should "set the host name" do
+    notice = build_notice
+    assert_equal hostname, notice.hostname
+  end
+
+  should "accept a backtrace from an exception or hash" do
+    array = ["user.rb:34:in `crazy'"]
+    exception = build_exception
+    exception.set_backtrace array
+    backtrace = Honeybadger::Backtrace.parse(array)
+    notice_from_exception = build_notice(:exception => exception)
+
+
+    assert_equal backtrace,
+                 notice_from_exception.backtrace,
+                 "backtrace was not correctly set from an exception"
+
+    notice_from_hash = build_notice(:backtrace => array)
+    assert_equal backtrace,
+                 notice_from_hash.backtrace,
+                 "backtrace was not correctly set from a hash"
+  end
+
+  should "pass its backtrace filters for parsing" do
+    backtrace_array = ['my/file/backtrace:3']
+    exception = build_exception
+    exception.set_backtrace(backtrace_array)
+    Honeybadger::Backtrace.expects(:parse).with(backtrace_array, {:filters => 'foo'})
+
+    notice = Honeybadger::Notice.new({:exception => exception, :backtrace_filters => 'foo'})
+  end
+
+  should "set the error class from an exception or hash" do
+    assert_accepts_exception_attribute :error_class do |exception|
+      exception.class.name
+    end
+  end
+
+  should "set the error message from an exception or hash" do
+    assert_accepts_exception_attribute :error_message do |exception|
+      "#{exception.class.name}: #{exception.message}"
+    end
+  end
+
+  should "accept parameters from a request or hash" do
+    parameters = { 'one' => 'two' }
+    notice_from_hash = build_notice(:parameters => parameters)
+    assert_equal notice_from_hash.parameters, parameters
+  end
+
+  should "accept session data from a session[:data] hash" do
+    data = { 'one' => 'two' }
+    notice = build_notice(:session => { :data => data })
+    assert_equal data, notice.session_data
+  end
+
+  should "accept session data from a session_data hash" do
+    data = { 'one' => 'two' }
+    notice = build_notice(:session_data => data)
+    assert_equal data, notice.session_data
+  end
+
+  should "accept an environment name" do
+    assert_equal 'development', build_notice(:environment_name => 'development').environment_name
+  end
+
+  should "accept CGI data from a hash" do
+    data = { 'string' => 'value' }
+    notice = build_notice(:cgi_data => data)
+    assert_equal data, notice.cgi_data, "should take CGI data from a hash"
+  end
+
+  should "accept notifier information" do
+    params = { :notifier_name    => 'a name for a notifier',
+               :notifier_version => '1.0.5',
+               :notifier_url     => 'http://notifiers.r.us/download' }
+    notice = build_notice(params)
+    assert_equal params[:notifier_name], notice.notifier_name
+    assert_equal params[:notifier_version], notice.notifier_version
+    assert_equal params[:notifier_url], notice.notifier_url
+  end
+
+  should "set sensible defaults without an exception" do
+    backtrace = Honeybadger::Backtrace.parse(build_backtrace_array)
+    notice = build_notice(:backtrace => build_backtrace_array)
+
+    assert_equal 'Notification', notice.error_message
+    assert_array_starts_with backtrace.lines, notice.backtrace.lines
+    assert_equal({}, notice.parameters)
+    assert_equal({}, notice.session_data)
+  end
+
+  should "use the caller as the backtrace for an exception without a backtrace" do
+    filters = Honeybadger::Configuration.new.backtrace_filters
+    backtrace = Honeybadger::Backtrace.parse(caller, :filters => filters)
+    notice = build_notice(:exception => StandardError.new('error'), :backtrace => nil)
+
+    assert_array_starts_with backtrace.lines, notice.backtrace.lines
+  end
+
+  should "convert unserializable objects to strings" do
+    assert_serializes_hash(:parameters)
+    assert_serializes_hash(:cgi_data)
+    assert_serializes_hash(:session_data)
+  end
+
+  should "filter parameters" do
+    assert_filters_hash(:parameters)
+  end
+
+  should "filter cgi data" do
+    assert_filters_hash(:cgi_data)
+  end
+
+  should "filter session" do
+    assert_filters_hash(:session_data)
+  end
+
+  should "remove rack.request.form_vars" do
+    original = {
+      "rack.request.form_vars" => "story%5Btitle%5D=The+TODO+label",
+      "abc" => "123"
+    }
+
+    notice = build_notice(:cgi_data => original)
+    assert_equal({"abc" => "123"}, notice.cgi_data)
+  end
+
+  should "not send empty request data" do
+    notice = build_notice
+    assert_nil notice.url
+    assert_nil notice.controller
+    assert_nil notice.action
+
+    json = notice.to_json
+    payload = JSON.parse(json)
+    assert_nil payload['request']['url']
+    assert_nil payload['request']['component']
+    assert_nil payload['request']['action']
+  end
+
+  %w(url controller action).each do |var|
+    should "send a request if #{var} is present" do
+      notice = build_notice(var.to_sym => 'value')
+      json = notice.to_json
+      payload = JSON.parse(json)
+      assert_not_nil payload['request']
+    end
+  end
+
+  %w(parameters cgi_data session_data).each do |var|
+    should "send a request if #{var} is present" do
+      notice = build_notice(var.to_sym => { 'key' => 'value' })
+      json = notice.to_json
+      payload = JSON.parse(json)
+      assert_not_nil payload['request']
+    end
+  end
+
+  should "not ignore an exception not matching ignore filters" do
+    notice = build_notice(:error_class       => 'ArgumentError',
+                          :ignore            => ['Argument'],
+                          :ignore_by_filters => [lambda { |notice| false }])
+    assert !notice.ignore?
+  end
+
+  should "ignore an exception with a matching error class" do
+    notice = build_notice(:error_class => 'ArgumentError',
+                          :ignore      => [ArgumentError])
+    assert notice.ignore?
+  end
+
+  should "ignore an exception with a matching error class name" do
+    notice = build_notice(:error_class => 'ArgumentError',
+                          :ignore      => ['ArgumentError'])
+    assert notice.ignore?
+  end
+
+  should "ignore an exception with a matching filter" do
+    filter = lambda {|notice| notice.error_class == 'ArgumentError' }
+    notice = build_notice(:error_class       => 'ArgumentError',
+                          :ignore_by_filters => [filter])
+    assert notice.ignore?
+  end
+
+  should "not raise without an ignore list" do
+    notice = build_notice(:ignore => nil, :ignore_by_filters => nil)
+    assert_nothing_raised do
+      notice.ignore?
+    end
+  end
+
+  ignored_error_classes = %w(
+    ActiveRecord::RecordNotFound
+    AbstractController::ActionNotFound
+    ActionController::RoutingError
+    ActionController::InvalidAuthenticityToken
+    CGI::Session::CookieStore::TamperedWithCookie
+    ActionController::UnknownAction
+  )
+
+  ignored_error_classes.each do |ignored_error_class|
+    should "ignore #{ignored_error_class} error by default" do
+      notice = build_notice(:error_class => ignored_error_class)
+      assert notice.ignore?
+    end
+  end
+
+  should "act like a hash" do
+    notice = build_notice(:error_message => 'some message')
+    assert_equal notice.error_message, notice[:error_message]
+  end
+
+  should "return params on notice[:request][:params]" do
+    params = { 'one' => 'two' }
+    notice = build_notice(:parameters => params)
+    assert_equal params, notice[:request][:params]
+  end
+
+  should "ensure #to_hash is called on objects that support it" do
+    assert_nothing_raised do
+      build_notice(:session => { :object => stub(:to_hash => {}) })
+    end
+  end
+
+
+  should "ensure #to_ary is called on objects that support it" do
+    assert_nothing_raised do
+      build_notice(:session => { :object => stub(:to_ary => {}) })
+    end
+  end
+
+  should "extract data from a rack environment hash" do
+    url = "https://subdomain.happylane.com:100/test/file.rb?var=value&var2=value2"
+    parameters = { 'var' => 'value', 'var2' => 'value2' }
+    env = Rack::MockRequest.env_for(url)
+
+    notice = build_notice(:rack_env => env)
+
+    assert_equal url, notice.url
+    assert_equal parameters, notice.parameters
+    assert_equal 'GET', notice.cgi_data['REQUEST_METHOD']
+  end
+
+  should "extract data from a rack environment hash with action_dispatch info" do
+    params = { 'controller' => 'users', 'action' => 'index', 'id' => '7' }
+    env = Rack::MockRequest.env_for('/', { 'action_dispatch.request.parameters' => params })
+
+    notice = build_notice(:rack_env => env)
+
+    assert_equal params, notice.parameters
+    assert_equal params['controller'], notice.component
+    assert_equal params['action'], notice.action
+  end
+
+  should "extract session data from a rack environment" do
+    session_data = { 'something' => 'some value' }
+    env = Rack::MockRequest.env_for('/', 'rack.session' => session_data)
+
+    notice = build_notice(:rack_env => env)
+
+    assert_equal session_data, notice.session_data
+  end
+
+  should "prefer passed session data to rack session data" do
+    session_data = { 'something' => 'some value' }
+    env = Rack::MockRequest.env_for('/')
+
+    notice = build_notice(:rack_env => env, :session_data => session_data)
+
+    assert_equal session_data, notice.session_data
+  end
+
+  should "not allow infinite recursion" do
+    hash = {:a => :a}
+    hash[:hash] = hash
+    notice = Honeybadger::Notice.new(:parameters => hash)
+    assert_equal "[possible infinite recursion halted]", notice.parameters[:hash]
+  end
+
+  def assert_accepts_exception_attribute(attribute, args = {}, &block)
+    exception = build_exception
+    block ||= lambda { exception.send(attribute) }
+    value = block.call(exception)
+
+    notice_from_exception = build_notice(args.merge(:exception => exception))
+
+    assert_equal notice_from_exception.send(attribute),
+                 value,
+                 "#{attribute} was not correctly set from an exception"
+
+    notice_from_hash = build_notice(args.merge(attribute => value))
+    assert_equal notice_from_hash.send(attribute),
+                 value,
+                 "#{attribute} was not correctly set from a hash"
+  end
+
+  def assert_serializes_hash(attribute)
+    [File.open(__FILE__), Proc.new { puts "boo!" }, Module.new].each do |object|
+      hash = {
+        :strange_object => object,
+        :sub_hash => {
+          :sub_object => object
+        },
+        :array => [object]
+      }
+      notice = build_notice(attribute => hash)
+      hash = notice.send(attribute)
+      assert_equal object.to_s, hash[:strange_object], "objects should be serialized"
+      assert_kind_of Hash, hash[:sub_hash], "subhashes should be kept"
+      assert_equal object.to_s, hash[:sub_hash][:sub_object], "subhash members should be serialized"
+      assert_kind_of Array, hash[:array], "arrays should be kept"
+      assert_equal object.to_s, hash[:array].first, "array members should be serialized"
+    end
+  end
+
+  def assert_filters_hash(attribute)
+    filters  = ["abc", :def]
+    original = { 'abc' => "123", 'def' => "456", 'ghi' => "789", 'nested' => { 'abc' => '100' },
+      'something_with_abc' => 'match the entire string'}
+    filtered = { 'abc'    => "[FILTERED]",
+                 'def'    => "[FILTERED]",
+                 'something_with_abc' => "match the entire string",
+                 'ghi'    => "789",
+                 'nested' => { 'abc' => '[FILTERED]' } }
+
+    notice = build_notice(:params_filters => filters, attribute => original)
+
+    assert_equal(filtered,
+                 notice.send(attribute))
+  end
+
+  def build_backtrace_array
+    ["app/models/user.rb:13:in `magic'",
+      "app/controllers/users_controller.rb:8:in `index'"]
+  end
+
+  def hostname
+    `hostname`.chomp
+  end
+end