errornot_notifier 0.1.0

data/test/notice_test.rb

@@ -0,0 +1,395 @@
+require File.dirname(__FILE__) + '/helper'
+
+class NoticeTest < Test::Unit::TestCase
+
+  include DefinesConstants
+
+  def configure
+    returning HoptoadNotifier::Configuration.new do |config|
+      config.api_key = 'abc123def456'
+    end
+  end
+
+  def build_notice(args = {})
+    configuration = args.delete(:configuration) || configure
+    HoptoadNotifier::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 "set the api key" do
+    api_key = 'key'
+    notice = build_notice(:api_key => api_key)
+    assert_equal api_key, notice.api_key
+  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 "accept a backtrace from an exception or hash" do
+    array = ["user.rb:34:in `crazy'"]
+    exception = build_exception
+    exception.set_backtrace array
+    backtrace = HoptoadNotifier::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)
+    HoptoadNotifier::Backtrace.expects(:parse).with(backtrace_array, {:filters => 'foo'})
+
+    notice = HoptoadNotifier::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 = HoptoadNotifier::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 = HoptoadNotifier::Configuration.new.backtrace_filters
+    backtrace = HoptoadNotifier::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
+
+  context "a Notice turned into XML" do
+    setup do
+      HoptoadNotifier.configure do |config|
+        config.api_key = "1234567890"
+      end
+
+      @exception = build_exception
+
+      @notice = build_notice({
+        :notifier_name    => 'a name',
+        :notifier_version => '0.1.0',
+        :notifier_url     => 'http://some.url/path',
+        :exception        => @exception,
+        :controller       => "controller",
+        :action           => "action",
+        :url              => "http://url.com",
+        :parameters       => { "paramskey"     => "paramsvalue",
+                               "nestparentkey" => { "nestkey" => "nestvalue" } },
+        :session_data     => { "sessionkey" => "sessionvalue" },
+        :cgi_data         => { "cgikey" => "cgivalue" },
+        :project_root     => "RAILS_ROOT",
+        :environment_name => "RAILS_ENV"
+      })
+
+      @document = @notice.to_xml
+    end
+
+    should "validate against the XML schema" do
+      assert_valid_notice_document @document
+    end
+
+    should "serialize a Notice to XML when sent #to_xml" do
+      assert_equal @document['api_key'], @notice.api_key
+
+      assert_equal @document['version'], @notice.notifier_version
+      assert_equal @document['error']['message'], @notice.error_message
+      #assert_equal @document['error']['raised_at'], Time.now
+      assert_equal @document['error']['backtrace'], @notice.backtrace.lines
+
+      assert_equal @document['error']['request']['url'], @notice.url
+      assert_equal @document['error']['request']['component'], @notice.controller
+      assert_equal @document['error']['request']['action'], @notice.action
+
+      assert_equal @document['error']['environment']['root'], "RAILS_ROOT"
+      assert_equal @document['error']['environment']['name'], "RAILS_ENV"
+
+      assert_equal @document['error']['request']['params'], {"paramskey"=>"paramsvalue", "nestparentkey"=>{"nestkey"=>"nestvalue"}}
+      assert_equal @document['error']['session'], { "sessionkey" => "sessionvalue" }
+      assert_equal @document['error']['request']['cgi-data'], { "cgikey" => "cgivalue" }
+    end
+  end
+
+  should "not send empty request data" do
+    notice = build_notice
+    assert_nil notice.url
+    assert_nil notice.controller
+    assert_nil notice.action
+
+    document = notice.to_xml
+    assert !document['error'].key?('request')
+
+    assert_valid_notice_document document
+  end
+
+  %w(url controller action).each do |var|
+    should "send a request if #{var} is present" do
+      notice = build_notice(var.to_sym => 'value')
+      document = notice.to_xml
+      assert document['error'].key?('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' })
+      document = notice.to_xml
+      assert !document['error']['request'].empty?
+    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
+
+  should "ignore RecordNotFound error by default" do
+    notice = build_notice(:error_class => 'ActiveRecord::RecordNotFound')
+    assert notice.ignore?
+  end
+
+  should "ignore RoutingError error by default" do
+    notice = build_notice(:error_class => 'ActionController::RoutingError')
+    assert notice.ignore?
+  end
+
+  should "ignore InvalidAuthenticityToken error by default" do
+    notice = build_notice(:error_class => 'ActionController::InvalidAuthenticityToken')
+    assert notice.ignore?
+  end
+
+  should "ignore TamperedWithCookie error by default" do
+    notice = build_notice(:error_class => 'CGI::Session::CookieStore::TamperedWithCookie')
+    assert notice.ignore?
+  end
+
+  should "ignore UnknownAction error by default" do
+    notice = build_notice(:error_class => 'ActionController::UnknownAction')
+    assert notice.ignore?
+  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 "extract data from a rack environment hash" do
+    # TODO: extract session data
+    # TODO: extract controller
+    # TODO: extract action
+    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
+
+  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_valid_notice_document(document)
+    assert document.kind_of?(Hash)
+  end
+
+  def assert_filters_hash(attribute)
+    filters  = %w(abc def)
+    original = { 'abc' => "123", 'def' => "456", 'ghi' => "789", 'nested' => { 'abc' => '100' } }
+    filtered = { 'abc'    => "[FILTERED]",
+                 'def'    => "[FILTERED]",
+                 '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
+end

data/test/notifier_test.rb

@@ -0,0 +1,222 @@
+require File.dirname(__FILE__) + '/helper'
+
+class NotifierTest < Test::Unit::TestCase
+
+  class OriginalException < Exception
+  end
+
+  class ContinuedException < Exception
+  end
+
+  include DefinesConstants
+
+  def setup
+    super
+    reset_config
+  end
+
+  def assert_sent(notice, notice_args)
+    assert_received(HoptoadNotifier::Notice, :new) {|expect| expect.with(has_entries(notice_args)) }
+    assert_received(notice, :to_xml)
+    assert_received(HoptoadNotifier.sender, :send_to_hoptoad) {|expect| expect.with(notice.to_xml) }
+  end
+
+  def set_public_env
+    HoptoadNotifier.configure { |config| config.environment_name = 'production' }
+  end
+
+  def set_development_env
+    HoptoadNotifier.configure { |config| config.environment_name = 'development' }
+  end
+
+  should "yield and save a configuration when configuring" do
+    yielded_configuration = nil
+    HoptoadNotifier.configure do |config|
+      yielded_configuration = config
+    end
+
+    assert_kind_of HoptoadNotifier::Configuration, yielded_configuration
+    assert_equal yielded_configuration, HoptoadNotifier.configuration
+  end
+
+  should "not remove existing config options when configuring twice" do
+    first_config = nil
+    HoptoadNotifier.configure do |config|
+      first_config = config
+    end
+    HoptoadNotifier.configure do |config|
+      assert_equal first_config, config
+    end
+  end
+
+  should "configure the sender" do
+    sender = stub_sender
+    HoptoadNotifier::Sender.stubs(:new => sender)
+    configuration = nil
+
+    HoptoadNotifier.configure { |yielded_config| configuration = yielded_config }
+
+    assert_received(HoptoadNotifier::Sender, :new) { |expect| expect.with(configuration) }
+    assert_equal sender, HoptoadNotifier.sender
+  end
+
+  should "create and send a notice for an exception" do
+    set_public_env
+    exception = build_exception
+    stub_sender!
+    notice = stub_notice!
+
+    HoptoadNotifier.notify(exception)
+
+    assert_sent notice, :exception => exception
+  end
+
+  should "create and send a notice for a hash" do
+    set_public_env
+    notice = stub_notice!
+    notice_args = { :error_message => 'uh oh' }
+    stub_sender!
+
+    HoptoadNotifier.notify(notice_args)
+
+    assert_sent(notice, notice_args)
+  end
+
+  should "create 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!
+
+    HoptoadNotifier.notify(exception, notice_args)
+
+    assert_sent(notice, notice_args.merge(:exception => exception))
+  end
+
+  should "not create a notice in a development environment" do
+    set_development_env
+    sender = stub_sender!
+
+    HoptoadNotifier.notify(build_exception)
+    HoptoadNotifier.notify_or_ignore(build_exception)
+
+    assert_received(sender, :send_to_hoptoad) {|expect| expect.never }
+  end
+
+  should "not deliver an ignored exception when notifying implicitly" do
+    set_public_env
+    exception = build_exception
+    sender = stub_sender!
+    notice = stub_notice!
+    notice.stubs(:ignore? => true)
+
+    HoptoadNotifier.notify_or_ignore(exception)
+
+    assert_received(sender, :send_to_hoptoad) {|expect| expect.never }
+  end
+
+  should "deliver an ignored exception when notifying manually" do
+    set_public_env
+    exception = build_exception
+    sender = stub_sender!
+    notice = stub_notice!
+    notice.stubs(:ignore? => true)
+
+    HoptoadNotifier.notify(exception)
+
+    assert_sent(notice, :exception => exception)
+  end
+
+  should "pass config to created notices" do
+    exception = build_exception
+    config_opts = { 'one' => 'two', 'three' => 'four' }
+    notice = stub_notice!
+    stub_sender!
+    HoptoadNotifier.configuration = stub('config', :merge => config_opts, :public? => true)
+
+    HoptoadNotifier.notify(exception)
+
+    assert_received(HoptoadNotifier::Notice, :new) do |expect|
+      expect.with(has_entries(config_opts))
+    end
+  end
+
+  context "building notice JSON for an exception" do
+    setup do
+      @params    = { :controller => "users", :action => "create" }
+      @exception = build_exception
+      @hash      = HoptoadNotifier.build_lookup_hash_for(@exception, @params)
+    end
+
+    should "set action" do
+      assert_equal @params[:action], @hash[:action]
+    end
+
+    should "set controller" do
+      assert_equal @params[:controller], @hash[:component]
+    end
+
+    should "set line number" do
+      assert @hash[:line_number] =~ /\d+/
+    end
+
+    should "set file" do
+      assert_match /test\/helper\.rb$/, @hash[:file]
+    end
+
+    should "set rails_env to production" do
+      assert_equal 'production', @hash[:environment_name]
+    end
+
+    should "set error class" do
+      assert_equal 'RuntimeError', @hash[:error_class]
+    end
+
+    should "not set file or line number with no backtrace" do
+      @exception.stubs(:backtrace).returns([])
+
+      @hash = HoptoadNotifier.build_lookup_hash_for(@exception)
+
+      assert_nil @hash[:line_number]
+      assert_nil @hash[:file]
+    end
+
+    should "not set action or controller when not provided" do
+      @hash = HoptoadNotifier.build_lookup_hash_for(@exception)
+
+      assert_nil @hash[:action]
+      assert_nil @hash[:controller]
+    end
+
+    context "when an exception that provides #original_exception is raised" do
+      setup do
+        @exception.stubs(:original_exception).returns(begin
+          raise NotifierTest::OriginalException.new
+        rescue Exception => e
+          e
+        end)
+      end
+
+      should "unwrap exceptions that provide #original_exception" do
+        @hash = HoptoadNotifier.build_lookup_hash_for(@exception)
+        assert_equal "NotifierTest::OriginalException", @hash[:error_class]
+      end
+    end
+
+    context "when an exception that provides #continued_exception is raised" do
+      setup do
+        @exception.stubs(:continued_exception).returns(begin
+          raise NotifierTest::ContinuedException.new
+        rescue Exception => e
+          e
+        end)
+      end
+
+      should "unwrap exceptions that provide #continued_exception" do
+        @hash = HoptoadNotifier.build_lookup_hash_for(@exception)
+        assert_equal "NotifierTest::ContinuedException", @hash[:error_class]
+      end
+    end
+  end
+end

data/test/rack_test.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/helper'
+
+class RackTest < Test::Unit::TestCase
+
+  should "call the upstream app with the environment" do
+    environment = { 'key' => 'value' }
+    app = lambda { |env| ['response', {}, env] }
+    stack = HoptoadNotifier::Rack.new(app)
+
+    response = stack.call(environment)
+
+    assert_equal ['response', {}, environment], response
+  end
+
+  should "deliver an exception raised while calling an upstream app" do
+    HoptoadNotifier.stubs(:notify_or_ignore)
+
+    exception = build_exception
+    environment = { 'key' => 'value' }
+    app = lambda do |env|
+      raise exception
+    end
+
+    begin
+      stack = HoptoadNotifier::Rack.new(app)
+      stack.call(environment)
+    rescue Exception => raised
+      assert_equal exception, raised
+    else
+      flunk "Didn't raise an exception"
+    end
+
+    assert_received(HoptoadNotifier, :notify_or_ignore) do |expect|
+      expect.with(exception, :rack_env => environment)
+    end
+  end
+
+  should "deliver an exception in rack.exception" do
+    HoptoadNotifier.stubs(:notify_or_ignore)
+    exception = build_exception
+    environment = { 'key' => 'value' }
+
+    response = [200, {}, ['okay']]
+    app = lambda do |env|
+      env['rack.exception'] = exception
+      response
+    end
+    stack = HoptoadNotifier::Rack.new(app)
+
+    actual_response = stack.call(environment)
+
+    assert_equal response, actual_response
+    assert_received(HoptoadNotifier, :notify_or_ignore) do |expect|
+      expect.with(exception, :rack_env => environment)
+    end
+  end
+
+end