square-hoptoad_notifier 2.4.8

data/lib/hoptoad_notifier/user_informer.rb

@@ -0,0 +1,23 @@
+module HoptoadNotifier
+  class UserInformer
+    def initialize(app)
+      @app = app
+    end
+
+    def replacement(with)
+      @replacement ||= HoptoadNotifier.configuration.user_information.gsub(/\{\{\s*error_id\s*\}\}/, with.to_s)
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      if env['hoptoad.error_id']
+        body.each_with_index do |chunk, i|
+          body[i] = chunk.to_s.gsub("<!-- HOPTOAD ERROR -->", replacement(env['hoptoad.error_id']))
+        end
+        headers['Content-Length'] = body.sum(&:length).to_s
+      end
+      [status, headers, body]
+    end
+  end
+end
+

data/lib/hoptoad_notifier/version.rb

@@ -0,0 +1,3 @@
+module HoptoadNotifier
+  VERSION = "2.4.8".freeze
+end

data/lib/hoptoad_tasks.rb

@@ -0,0 +1,44 @@
+require 'net/http'
+require 'uri'
+require 'active_support'
+
+# Capistrano tasks for notifying Hoptoad of deploys
+module HoptoadTasks
+
+  # Alerts Hoptoad of a deploy.
+  #
+  # @param [Hash] opts Data about the deploy that is set to Hoptoad
+  #
+  # @option opts [String] :rails_env Environment of the deploy (production, staging)
+  # @option opts [String] :scm_revision The given revision/sha that is being deployed
+  # @option opts [String] :scm_repository Address of your repository to help with code lookups
+  # @option opts [String] :local_username Who is deploying
+  def self.deploy(opts = {})
+    if HoptoadNotifier.configuration.api_key.blank?
+      puts "I don't seem to be configured with an API key.  Please check your configuration."
+      return false
+    end
+
+    if opts[:rails_env].blank?
+      puts "I don't know to which Rails environment you are deploying (use the TO=production option)."
+      return false
+    end
+
+    params = {'api_key' => opts.delete(:api_key) ||
+                             HoptoadNotifier.configuration.api_key}
+    opts.each {|k,v| params["deploy[#{k}]"] = v }
+
+    url = URI.parse("http://#{HoptoadNotifier.configuration.host || 'hoptoadapp.com'}/deploys.txt")
+
+    proxy = Net::HTTP.Proxy(HoptoadNotifier.configuration.proxy_host,
+                            HoptoadNotifier.configuration.proxy_port,
+                            HoptoadNotifier.configuration.proxy_user,
+                            HoptoadNotifier.configuration.proxy_pass)
+
+    response = proxy.post_form(url, params)
+
+    puts response.body
+    return Net::HTTPSuccess === response
+  end
+end
+

data/lib/rails/generators/hoptoad/hoptoad_generator.rb

@@ -0,0 +1,94 @@
+require 'rails/generators'
+
+class HoptoadGenerator < Rails::Generators::Base
+
+  class_option :api_key, :aliases => "-k", :type => :string, :desc => "Your Hoptoad API key"
+  class_option :heroku, :type => :boolean, :desc => "Use the Heroku addon to provide your Hoptoad API key"
+
+  def self.source_root
+    @_hoptoad_source_root ||= File.expand_path("../../../../../generators/hoptoad/templates", __FILE__)
+  end
+
+  def install
+    ensure_api_key_was_configured
+    ensure_plugin_is_not_present
+    append_capistrano_hook
+    generate_initializer unless api_key_configured?
+    determine_api_key if heroku?
+    test_hoptoad
+  end
+
+  private
+
+  def ensure_api_key_was_configured
+    if !options[:api_key] && !options[:heroku] && !api_key_configured?
+      puts "Must pass --api-key or --heroku or create config/initializers/hoptoad.rb"
+      exit
+    end
+  end
+
+  def ensure_plugin_is_not_present
+    if plugin_is_present?
+      puts "You must first remove the hoptoad_notifier plugin. Please run: script/plugin remove hoptoad_notifier"
+      exit
+    end
+  end
+
+  def append_capistrano_hook
+    if File.exists?('config/deploy.rb') && File.exists?('Capfile')
+      append_file('config/deploy.rb', <<-HOOK)
+
+        require './config/boot'
+        require 'hoptoad_notifier/capistrano'
+      HOOK
+    end
+  end
+
+  def api_key_expression
+    s = if options[:api_key]
+      "'#{options[:api_key]}'"
+    elsif options[:heroku]
+      "ENV['HOPTOAD_API_KEY']"
+    end
+  end
+
+  def generate_initializer
+    template 'initializer.rb', 'config/initializers/hoptoad.rb'
+  end
+
+  def determine_api_key
+    puts "Attempting to determine your API Key from Heroku..."
+    ENV['HOPTOAD_API_KEY'] = heroku_api_key
+    if ENV['HOPTOAD_API_KEY'].blank?
+      puts "... Failed."
+      puts "WARNING: We were unable to detect the Hoptoad API Key from your Heroku environment."
+      puts "Your Heroku application environment may not be configured correctly."
+      exit 1
+    else
+      puts "... Done."
+      puts "Heroku's Hoptoad API Key is '#{ENV['HOPTOAD_API_KEY']}'"
+    end
+  end
+
+  def heroku_api_key
+    `heroku console 'puts ENV[%{HOPTOAD_API_KEY}]'`.split("\n").first
+  end
+
+  def heroku?
+    options[:heroku] ||
+      system("grep HOPTOAD_API_KEY config/initializers/hoptoad.rb") ||
+      system("grep HOPTOAD_API_KEY config/environment.rb")
+  end
+
+  def api_key_configured?
+    File.exists?('config/initializers/hoptoad.rb')
+  end
+
+  def test_hoptoad
+    puts run("rake hoptoad:test --trace")
+  end
+
+  def plugin_is_present?
+    File.exists?('vendor/plugins/hoptoad_notifier')
+  end
+end

data/lib/templates/javascript_notifier.erb

@@ -0,0 +1,13 @@
+<%= javascript_tag %Q{
+    var notifierJsScheme = (("https:" == document.location.protocol) ? "https://" : "http://");
+    document.write(unescape("%3Cscript src='" + notifierJsScheme + "#{host}/javascripts/notifier.js' type='text/javascript'%3E%3C/script%3E"));
+  }
+%>
+
+<%= javascript_tag %Q{
+    Hoptoad.setKey('#{api_key}');
+    Hoptoad.setHost('#{host}');
+    Hoptoad.setEnvironment('#{environment}');
+    Hoptoad.setErrorDefaults({ url: "#{escape_javascript url}", component: "#{controller_name}", action: "#{action_name}" });
+  } 
+%>

data/lib/templates/rescue.erb

@@ -0,0 +1,91 @@
+<script type="text/javascript">
+var Hoptoad = {
+  host    : <%= host.to_json %>,
+  api_key : <%= api_key.to_json %>,
+  notice  : <%= notice.to_json %>,
+  message : 'This error exists in production!',
+
+  initialize: function() {
+    if (this.initialized) {
+      return;
+    } else {
+      this.initialized = true;
+    }
+
+    var data = [];
+
+    for (var key in this.notice) {
+      data[data.length] = 'notice[' + key + ']=' + this.notice[key];
+    }
+
+    data[data.length] = 'notice[api_key]=' + this.api_key;
+    data[data.length] = 'callback=Hoptoad.onSuccess';
+    data[data.length] = '_=' + (new Date()).getTime();
+
+    var head = document.getElementsByTagName('head')[0];
+    var done = false;
+
+    var
+    script = document.createElement('script');
+    script.src  = 'http://' + this.host + '/notices_api/v1/notices/exist?' +
+                  data.join('&');
+    script.type = 'text/javascript';
+    script.onload = script.onreadystatechange = function(){
+      if (!done && (!this.readyState ||
+          this.readyState == 'loaded' || this.readyState == 'complete')) {
+
+        done = true;
+
+        // Handle memory leak in IE. (via jQuery)
+        script.onload = script.onreadystatechange = null;
+        head.removeChild(script);
+      }
+    };
+
+    head.appendChild(script);
+  },
+
+  onSuccess: function(error) {
+    var body    = document.getElementsByTagName('body')[0];
+    var text    = document.createTextNode(this.message);
+    var element = document.createElement('a');
+
+    element.id   = 'hoptoad';
+    element.href = 'http://' + error.subdomain + '.' + this.host +
+                   '/projects/' + error.project_id + '/errors/' + error.id;
+    element.appendChild(text);
+
+    body.insertBefore(element, body.firstChild);
+
+    var h1      = document.getElementsByTagName('h1')[0];
+    var pre     = document.getElementsByTagName('pre')[0];
+    var wrapper = document.createElement('div');
+
+    wrapper.id = 'wrapper';
+    wrapper.appendChild(h1);
+    wrapper.appendChild(pre);
+
+    body.insertBefore(wrapper, body.children[1]);
+  }
+};
+
+window.onload = function() {
+  Hoptoad.initialize.apply(Hoptoad);
+};
+</script>
+
+<style type="text/css">
+#hoptoad {
+  background: #FFF url(http://hoptoadapp.com/images/fell-off-the-toad.gif) no-repeat top right;
+  color: #F00;
+  padding: 45px 101px 45px 12px;
+  font-size: 14px;
+  font-weight: bold;
+  display: block;
+  float: right;
+}
+
+#wrapper {
+  padding-right: 360px;
+}
+</style>

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,331 @@
+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)
+    Class.new(ActionController::Base).tap 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|
+      next if key.match(/^hoptoad\./) # We added this key.
+
+      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 session and env" do
+    filtered_params = { "abc" => "123",
+                        "def" => "456",
+                        "ghi" => "[FILTERED]" }
+    filtered_session = { "abc" => "123",
+                         "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" },
+                                               :session => { "abc" => "123",
+                                                             "ghi" => "789" })
+    assert_sent_hash filtered_params, '/notice/request/params'
+    assert_sent_hash filtered_cgi, '/notice/request/cgi-data'
+    assert_sent_hash filtered_session, '/notice/request/session'
+  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