hatless-hoptoad_notifier 2.2.6

data/rails/init.rb

@@ -0,0 +1 @@
+require 'hoptoad_notifier/rails'

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 'hoptoad_notifier'
+require 'rails/init'
+
+fail "Please supply an API Key as the first argument" if ARGV.empty?
+
+host = ARGV[1]
+host ||= "hoptoadapp.com"
+
+secure = (ARGV[2] == "secure")
+
+exception = begin
+              raise "Testing hoptoad notifier with secure = #{secure}. If you can see this, it works."
+            rescue => foo
+              foo
+            end
+
+HoptoadNotifier.configure do |config|
+  config.secure  = secure
+  config.host    = host
+  config.api_key = ARGV.first
+end
+puts "Configuration:"
+HoptoadNotifier.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}"
+HoptoadNotifier.notify(exception)
+

data/test/backtrace_test.rb

@@ -0,0 +1,118 @@
+require File.dirname(__FILE__) + '/helper'
+
+class BacktraceTest < Test::Unit::TestCase
+
+  should "parse a backtrace into lines" do
+    array = [
+      "app/models/user.rb:13:in `magic'",
+      "app/controllers/users_controller.rb:8:in `index'"
+    ]
+
+    backtrace = HoptoadNotifier::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 "be equal with equal lines" do
+    one = build_backtrace_array
+    two = one.dup
+    assert_equal one, two
+
+    assert_equal HoptoadNotifier::Backtrace.parse(one), HoptoadNotifier::Backtrace.parse(two)
+  end
+
+  should "parse massive one-line exceptions into multiple lines" do
+    original_backtrace = HoptoadNotifier::Backtrace.
+      parse(["one:1:in `one'\n   two:2:in `two'\n      three:3:in `three`"])
+    expected_backtrace = HoptoadNotifier::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'
+      HoptoadNotifier.configure {|config| config.project_root = @project_root }
+    end
+
+    teardown do
+      reset_config
+    end
+
+    should "filter out the project root" do
+      backtrace_with_root = HoptoadNotifier::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 = HoptoadNotifier::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
+      HoptoadNotifier.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 =
+        HoptoadNotifier::Backtrace.parse(backtrace, :filters => default_filters)
+
+      backtrace_without_root =
+        HoptoadNotifier::Backtrace.parse(backtrace)
+
+      assert_equal backtrace_without_root, backtrace_with_root
+    end
+  end
+
+  should "remove notifier trace" do
+    inside_notifier  = ['lib/hoptoad_notifier.rb:13:in `voodoo`']
+    outside_notifier = ['users_controller:8:in `index`']
+
+    without_inside = HoptoadNotifier::Backtrace.parse(outside_notifier)
+    with_inside    = HoptoadNotifier::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 = HoptoadNotifier::Backtrace.parse(["foo:13:in `one'", "baz:14:in `two'"],
+                                             :filters => filters)
+    expected = HoptoadNotifier::Backtrace.parse(["bar:13:in `one'", "baz:14:in `two'"])
+    assert_equal expected, input
+  end
+
+  def build_backtrace_array
+    ["app/models/user.rb:13:in `magic'",
+      "app/controllers/users_controller.rb:8:in `index'"]
+  end
+
+  def default_filters
+    HoptoadNotifier::Configuration::DEFAULT_BACKTRACE_FILTERS
+  end
+
+end

data/test/catcher_test.rb

@@ -0,0 +1,324 @@
+require File.dirname(__FILE__) + '/helper'
+
+class ActionControllerCatcherTest < Test::Unit::TestCase
+
+  include DefinesConstants
+
+  def setup
+    super
+    reset_config
+    HoptoadNotifier.sender = CollectingSender.new
+    define_constant('RAILS_ROOT', '/path/to/rails/root')
+  end
+
+  def ignore(exception_class)
+    HoptoadNotifier.configuration.ignore << exception_class
+  end
+
+  def build_controller_class(&definition)
+    returning Class.new(ActionController::Base) do |klass|
+      klass.__send__(:include, HoptoadNotifier::Rails::ActionControllerCatcher)
+      klass.class_eval(&definition) if definition
+      define_constant('HoptoadTestController', klass)
+    end
+  end
+
+  def assert_sent_hash(hash, xpath)
+    hash.each do |key, value|
+      element_xpath = "#{xpath}/var[@key = '#{key}']"
+      if value.respond_to?(:to_hash)
+        assert_sent_hash value.to_hash, element_xpath
+      else
+        assert_sent_element value, element_xpath
+      end
+    end
+  end
+
+  def assert_sent_element(value, xpath)
+    assert_valid_node last_sent_notice_document, xpath, stringify_array_elements(value).to_s
+  end
+
+  def stringify_array_elements(data)
+    if data.respond_to?(:to_ary)
+      data.collect do |value|
+        stringify_array_elements(value)
+      end
+    else
+      data.to_s
+    end
+  end
+
+  def assert_sent_request_info_for(request)
+    params = request.parameters.to_hash
+    assert_sent_hash params, '/notice/request/params'
+    assert_sent_element params['controller'], '/notice/request/component'
+    assert_sent_element params['action'], '/notice/request/action'
+    assert_sent_element url_from_request(request), '/notice/request/url'
+    assert_sent_hash request.env, '/notice/request/cgi-data'
+  end
+
+  def url_from_request(request)
+    url = "#{request.protocol}#{request.host}"
+
+    unless [80, 443].include?(request.port)
+      url << ":#{request.port}"
+    end
+
+    url << request.request_uri
+    url
+  end
+
+  def sender
+    HoptoadNotifier.sender
+  end
+
+  def last_sent_notice_xml
+    sender.collected.last
+  end
+
+  def last_sent_notice_document
+    assert_not_nil xml = last_sent_notice_xml, "No xml was sent"
+    Nokogiri::XML.parse(xml)
+  end
+
+  def process_action(opts = {}, &action)
+    opts[:request]  ||= ActionController::TestRequest.new
+    opts[:response] ||= ActionController::TestResponse.new
+    klass = build_controller_class do
+      cattr_accessor :local
+      define_method(:index, &action)
+      def local_request?
+        local
+      end
+    end
+    if opts[:filters]
+      klass.filter_parameter_logging *opts[:filters]
+    end
+    if opts[:user_agent]
+      if opts[:request].respond_to?(:user_agent=)
+        opts[:request].user_agent = opts[:user_agent]
+      else
+        opts[:request].env["HTTP_USER_AGENT"] = opts[:user_agent]
+      end
+    end
+    if opts[:port]
+      opts[:request].port = opts[:port]
+    end
+    klass.consider_all_requests_local = opts[:all_local]
+    klass.local                       = opts[:local]
+    controller = klass.new
+    controller.stubs(:rescue_action_in_public_without_hoptoad)
+    opts[:request].query_parameters = opts[:request].query_parameters.merge(opts[:params] || {})
+    opts[:request].session = ActionController::TestSession.new(opts[:session] || {})
+    controller.process(opts[:request], opts[:response])
+    controller
+  end
+
+  def process_action_with_manual_notification(args = {})
+    process_action(args) do
+      notify_hoptoad(:error_message => 'fail')
+      # Rails will raise a template error if we don't render something
+      render :nothing => true
+    end
+  end
+
+  def process_action_with_automatic_notification(args = {})
+    process_action(args) { raise "Hello" }
+  end
+
+  should "deliver notices from exceptions raised in public requests" do
+    process_action_with_automatic_notification
+    assert_caught_and_sent
+  end
+
+  should "not deliver notices from exceptions in local requests" do
+    process_action_with_automatic_notification(:local => true)
+    assert_caught_and_not_sent
+  end
+
+  should "not deliver notices from exceptions when all requests are local" do
+    process_action_with_automatic_notification(:all_local => true)
+    assert_caught_and_not_sent
+  end
+
+  should "not deliver notices from actions that don't raise" do
+    controller = process_action { render :text => 'Hello' }
+    assert_caught_and_not_sent
+    assert_equal 'Hello', controller.response.body
+  end
+
+  should "not deliver ignored exceptions raised by actions" do
+    ignore(RuntimeError)
+    process_action_with_automatic_notification
+    assert_caught_and_not_sent
+  end
+
+  should "deliver ignored exception raised manually" do
+    ignore(RuntimeError)
+    process_action_with_manual_notification
+    assert_caught_and_sent
+  end
+
+  should "deliver manually sent notices in public requests" do
+    process_action_with_manual_notification
+    assert_caught_and_sent
+  end
+
+  should "not deliver manually sent notices in local requests" do
+    process_action_with_manual_notification(:local => true)
+    assert_caught_and_not_sent
+  end
+
+  should "not deliver manually sent notices when all requests are local" do
+    process_action_with_manual_notification(:all_local => true)
+    assert_caught_and_not_sent
+  end
+
+  should "continue with default behavior after delivering an exception" do
+    controller = process_action_with_automatic_notification(:public => true)
+    # TODO: can we test this without stubbing?
+    assert_received(controller, :rescue_action_in_public_without_hoptoad)
+  end
+
+  should "not create actions from Hoptoad methods" do
+    controller = build_controller_class.new
+    assert_equal [], HoptoadNotifier::Rails::ActionControllerCatcher.instance_methods
+  end
+
+  should "ignore exceptions when user agent is being ignored by regular expression" do
+    HoptoadNotifier.configuration.ignore_user_agent_only = [/Ignored/]
+    process_action_with_automatic_notification(:user_agent => 'ShouldBeIgnored')
+    assert_caught_and_not_sent
+  end
+
+  should "ignore exceptions when user agent is being ignored by string" do
+    HoptoadNotifier.configuration.ignore_user_agent_only = ['IgnoredUserAgent']
+    process_action_with_automatic_notification(:user_agent => 'IgnoredUserAgent')
+    assert_caught_and_not_sent
+  end
+
+  should "not ignore exceptions when user agent is not being ignored" do
+    HoptoadNotifier.configuration.ignore_user_agent_only = ['IgnoredUserAgent']
+    process_action_with_automatic_notification(:user_agent => 'NonIgnoredAgent')
+    assert_caught_and_sent
+  end
+
+  should "send session data for manual notifications" do
+    data = { 'one' => 'two' }
+    process_action_with_manual_notification(:session => data)
+    assert_sent_hash data, "/notice/request/session"
+  end
+
+  should "send session data for automatic notification" do
+    data = { 'one' => 'two' }
+    process_action_with_automatic_notification(:session => data)
+    assert_sent_hash data, "/notice/request/session"
+  end
+
+  should "send request data for manual notification" do
+    params = { 'controller' => "hoptoad_test", 'action' => "index" }
+    controller = process_action_with_manual_notification(:params => params)
+    assert_sent_request_info_for controller.request
+  end
+
+  should "send request data for manual notification with non-standard port" do
+    params = { 'controller' => "hoptoad_test", 'action' => "index" }
+    controller = process_action_with_manual_notification(:params => params, :port => 81)
+    assert_sent_request_info_for controller.request
+  end
+
+  should "send request data for automatic notification" do
+    params = { 'controller' => "hoptoad_test", 'action' => "index" }
+    controller = process_action_with_automatic_notification(:params => params)
+    assert_sent_request_info_for controller.request
+  end
+
+  should "send request data for automatic notification with non-standard port" do
+    params = { 'controller' => "hoptoad_test", 'action' => "index" }
+    controller = process_action_with_automatic_notification(:params => params, :port => 81)
+    assert_sent_request_info_for controller.request
+  end
+
+  should "use standard rails logging filters on params and env" do
+    filtered_params = { "abc" => "123",
+                        "def" => "456",
+                        "ghi" => "[FILTERED]" }
+    ENV['ghi'] = 'abc'
+    filtered_env = { 'ghi' => '[FILTERED]' }
+    filtered_cgi = { 'REQUEST_METHOD' => '[FILTERED]' }
+
+    process_action_with_automatic_notification(:filters => [:ghi, :request_method],
+                                               :params => { "abc" => "123",
+                                                            "def" => "456",
+                                                            "ghi" => "789" })
+    assert_sent_hash filtered_params, '/notice/request/params'
+    assert_sent_hash filtered_cgi, '/notice/request/cgi-data'
+  end
+
+  context "for a local error with development lookup enabled" do
+    setup do
+      HoptoadNotifier.configuration.development_lookup = true
+      HoptoadNotifier.stubs(:build_lookup_hash_for).returns({ :awesome => 2 })
+
+      @controller = process_action_with_automatic_notification(:local => true)
+      @response   = @controller.response
+    end
+
+    should "append custom CSS and JS to response body for a local error" do
+      assert_match /text\/css/, @response.body
+      assert_match /text\/javascript/, @response.body
+    end
+
+    should "contain host, API key and notice JSON" do
+      assert_match HoptoadNotifier.configuration.host.to_json, @response.body
+      assert_match HoptoadNotifier.configuration.api_key.to_json, @response.body
+      assert_match ({ :awesome => 2 }).to_json, @response.body
+    end
+  end
+
+  context "for a local error with development lookup disabled" do
+    setup do
+      HoptoadNotifier.configuration.development_lookup = false
+
+      @controller = process_action_with_automatic_notification(:local => true)
+      @response   = @controller.response
+    end
+
+    should "not append custom CSS and JS to response for a local error" do
+      assert_no_match /text\/css/, @response.body
+      assert_no_match /text\/javascript/, @response.body
+    end
+  end
+
+  should "call session.to_hash if available" do
+    hash_data = {:key => :value}
+
+    session = ActionController::TestSession.new
+    ActionController::TestSession.stubs(:new).returns(session)
+    session.stubs(:to_hash).returns(hash_data)
+
+    process_action_with_automatic_notification
+    assert_received(session, :to_hash)
+    assert_received(session, :data) { |expect| expect.never }
+    assert_caught_and_sent
+  end
+
+  should "call session.data if session.to_hash is undefined" do
+    hash_data = {:key => :value}
+
+    session = ActionController::TestSession.new
+    ActionController::TestSession.stubs(:new).returns(session)
+    session.stubs(:data).returns(hash_data)
+    if session.respond_to?(:to_hash)
+      class << session
+        undef to_hash
+      end
+    end
+
+    process_action_with_automatic_notification
+    assert_received(session, :to_hash) { |expect| expect.never }
+    assert_received(session, :data) { |expect| expect.at_least_once }
+    assert_caught_and_sent
+  end
+
+end

data/test/configuration_test.rb

@@ -0,0 +1,208 @@
+require File.dirname(__FILE__) + '/helper'
+
+class ConfigurationTest < Test::Unit::TestCase
+
+  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,    HoptoadNotifier::VERSION
+    assert_config_default :notifier_name,       'Hoptoad Notifier'
+    assert_config_default :notifier_url,        'http://hoptoadapp.com'
+    assert_config_default :secure,              false
+    assert_config_default :host,                'hoptoadapp.com'
+    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,
+                          HoptoadNotifier::Configuration::DEFAULT_PARAMS_FILTERS
+    assert_config_default :backtrace_filters,
+                          HoptoadNotifier::Configuration::DEFAULT_BACKTRACE_FILTERS
+    assert_config_default :ignore,
+                          HoptoadNotifier::Configuration::IGNORE_DEFAULT
+    assert_config_default :development_lookup, true
+    assert_config_default :framework, 'Standalone'
+  end
+
+  should "provide default values for secure connections" do
+    config = HoptoadNotifier::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 = HoptoadNotifier::Configuration.new
+    config.secure = false
+    assert_equal 80, config.port
+    assert_equal 'http', config.protocol
+  end
+
+  should "not cache inferred ports" do
+    config = HoptoadNotifier::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 :development_lookup
+    assert_config_overridable :logger
+  end
+
+  should "have an api key" do
+    assert_config_overridable :api_key
+  end
+
+  should "act like a hash" do
+    config = HoptoadNotifier::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, :development_lookup].each do |option|
+      assert_equal config[option], hash[option], "Wrong value for #{option}"
+    end
+  end
+
+  should "be mergable" do
+    config = HoptoadNotifier::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 "warn when attempting to read environment filters" do
+    config = HoptoadNotifier::Configuration.new
+    config.
+      expects(:warn).
+      with(regexp_matches(/deprecated/i))
+    assert_equal [], config.environment_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 = HoptoadNotifier::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 = HoptoadNotifier::Configuration.new
+    assert_same_elements %w(development test cucumber), config.development_environments
+  end
+
+  should "be public in a public environment" do
+    config = HoptoadNotifier::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 = HoptoadNotifier::Configuration.new
+    config.development_environments = %w(staging)
+    config.environment_name = 'staging'
+    assert !config.public?
+  end
+
+  should "be public without an environment name" do
+    config = HoptoadNotifier::Configuration.new
+    assert config.public?
+  end
+
+  should "use the assigned logger if set" do
+    config = HoptoadNotifier::Configuration.new
+    config.logger = "CUSTOM LOGGER"
+    assert_equal "CUSTOM LOGGER", config.logger
+  end
+
+  def assert_config_default(option, default_value, config = nil)
+    config ||= HoptoadNotifier::Configuration.new
+    assert_equal default_value, config.send(option)
+  end
+
+  def assert_config_overridable(option, value = 'a value')
+    config = HoptoadNotifier::Configuration.new
+    config.send(:"#{option}=", value)
+    assert_equal value, config.send(option)
+  end
+
+  def assert_appends_value(option, &block)
+    config = HoptoadNotifier::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 = HoptoadNotifier::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