errornot_notifier 0.1.0 → 1.0.0

data/test/helper.rb

@@ -19,7 +19,7 @@ require 'active_support'
 require 'nokogiri'
 require 'rack'
 
-require "hoptoad_notifier"
+require "errornot_notifier"
 
 begin require 'redgreen'; rescue LoadError; end
 
@@ -29,7 +29,7 @@ module TestMethods
   end
 
   def do_raise
-    raise "Hoptoad"
+    raise "Errornot"
   end
 
   def do_not_raise
@@ -45,17 +45,17 @@ module TestMethods
   end
 
   def manual_notify
-    notify_hoptoad(Exception.new)
+    notify_errornot(Exception.new)
     render :text => "Success"
   end
 
   def manual_notify_ignored
-    notify_hoptoad(ActiveRecord::RecordNotFound.new("404"))
+    notify_errornot(ActiveRecord::RecordNotFound.new("404"))
     render :text => "Success"
   end
 end
 
-class HoptoadController < ActionController::Base
+class ErrornotController < ActionController::Base
   include TestMethods
 end
 
@@ -96,11 +96,11 @@ class Test::Unit::TestCase
   end
 
   def stub_sender
-    stub('sender', :send_to_hoptoad => nil)
+    stub('sender', :send_to_errornot => nil)
   end
 
   def stub_sender!
-    HoptoadNotifier.sender = stub_sender
+    ErrornotNotifier.sender = stub_sender
   end
 
   def stub_notice
@@ -109,23 +109,24 @@ class Test::Unit::TestCase
 
   def stub_notice!
     returning stub_notice do |notice|
-      HoptoadNotifier::Notice.stubs(:new => notice)
+      ErrornotNotifier::Notice.stubs(:new => notice)
     end
   end
 
   def create_dummy
-    HoptoadNotifier::DummySender.new
+    ErrornotNotifier::DummySender.new
   end
 
   def reset_config
-    HoptoadNotifier.configuration = nil
-    HoptoadNotifier.configure do |config|
+    ErrornotNotifier.configuration = nil
+    ErrornotNotifier.configure do |config|
+      config.host = "localhost"
       config.api_key = 'abc123'
     end
   end
 
   def clear_backtrace_filters
-    HoptoadNotifier.configuration.backtrace_filters.clear
+    ErrornotNotifier.configuration.backtrace_filters.clear
   end
 
   def build_exception
@@ -155,11 +156,11 @@ class Test::Unit::TestCase
   end
 
   def assert_caught_and_sent
-    assert !HoptoadNotifier.sender.collected.empty?
+    assert !ErrornotNotifier.sender.collected.empty?
   end
 
   def assert_caught_and_not_sent
-    assert HoptoadNotifier.sender.collected.empty?
+    assert ErrornotNotifier.sender.collected.empty?
   end
 
   def assert_array_starts_with(expected, actual)
@@ -217,7 +218,7 @@ class CollectingSender
     @collected = []
   end
 
-  def send_to_hoptoad(data)
+  def send_to_errornot(data)
     @collected << data
   end
 end

data/test/logger_test.rb

@@ -11,27 +11,29 @@ class LoggerTest < Test::Unit::TestCase
   end
 
   def send_notice
-    HoptoadNotifier.sender.send_to_hoptoad('data')
+    ErrornotNotifier.sender.send_to_errornot('data')
   end
 
   def stub_verbose_log
-    HoptoadNotifier.stubs(:write_verbose_log)
+    ErrornotNotifier.stubs(:write_verbose_log)
   end
 
   def assert_logged(expected)
-    assert_received(HoptoadNotifier, :write_verbose_log) do |expect|
+    assert_received(ErrornotNotifier, :write_verbose_log) do |expect|
       expect.with {|actual| actual =~ expected }
     end
   end
 
   def assert_not_logged(expected)
-    assert_received(HoptoadNotifier, :write_verbose_log) do |expect|
+    assert_received(ErrornotNotifier, :write_verbose_log) do |expect|
       expect.with {|actual| actual =~ expected }.never
     end
   end
 
   def configure
-    HoptoadNotifier.configure { |config| }
+    ErrornotNotifier.configure { |config|
+      config.host = "localhost"
+    }
   end
 
   should "report that notifier is ready when configured" do
@@ -42,7 +44,7 @@ class LoggerTest < Test::Unit::TestCase
 
   should "not report that notifier is ready when internally configured" do
     stub_verbose_log
-    HoptoadNotifier.configure(true) { |config| }
+    ErrornotNotifier.configure(true) { |config| }
     assert_not_logged /.*/
   end
 
@@ -52,7 +54,7 @@ class LoggerTest < Test::Unit::TestCase
     stub_http(Net::HTTPSuccess)
     send_notice
     assert_logged /Environment Info:/
-    assert_not_logged /Response from Hoptoad:/
+    assert_not_logged /Response from Errornot:/
   end
 
   should "print environment info on a failed notification without a body" do
@@ -61,7 +63,7 @@ class LoggerTest < Test::Unit::TestCase
     stub_http(Net::HTTPError)
     send_notice
     assert_logged /Environment Info:/
-    assert_not_logged /Response from Hoptoad:/
+    assert_not_logged /Response from Errornot:/
   end
 
   should "print environment info and response on a success with a body" do
@@ -70,7 +72,7 @@ class LoggerTest < Test::Unit::TestCase
     stub_http(Net::HTTPSuccess, 'test')
     send_notice
     assert_logged /Environment Info:/
-    assert_logged /Response from Hoptoad:/
+    assert_logged /Response from Errornot:/
   end
 
   should "print environment info and response on a failure with a body" do
@@ -79,7 +81,7 @@ class LoggerTest < Test::Unit::TestCase
     stub_http(Net::HTTPError, 'test')
     send_notice
     assert_logged /Environment Info:/
-    assert_logged /Response from Hoptoad:/
+    assert_logged /Response from Errornot:/
   end
 
 end

data/test/notice_test.rb

@@ -5,14 +5,14 @@ class NoticeTest < Test::Unit::TestCase
   include DefinesConstants
 
   def configure
-    returning HoptoadNotifier::Configuration.new do |config|
+    returning ErrornotNotifier::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))
+    ErrornotNotifier::Notice.new(configuration.merge(args))
   end
 
   def stub_request(attrs = {})
@@ -59,7 +59,7 @@ class NoticeTest < Test::Unit::TestCase
     array = ["user.rb:34:in `crazy'"]
     exception = build_exception
     exception.set_backtrace array
-    backtrace = HoptoadNotifier::Backtrace.parse(array)
+    backtrace = ErrornotNotifier::Backtrace.parse(array)
     notice_from_exception = build_notice(:exception => exception)
 
 
@@ -77,9 +77,9 @@ class NoticeTest < Test::Unit::TestCase
     backtrace_array = ['my/file/backtrace:3']
     exception = build_exception
     exception.set_backtrace(backtrace_array)
-    HoptoadNotifier::Backtrace.expects(:parse).with(backtrace_array, {:filters => 'foo'})
+    ErrornotNotifier::Backtrace.expects(:parse).with(backtrace_array, {:filters => 'foo'})
 
-    notice = HoptoadNotifier::Notice.new({:exception => exception, :backtrace_filters => 'foo'})
+    notice = ErrornotNotifier::Notice.new({:exception => exception, :backtrace_filters => 'foo'})
   end
 
   should "set the error class from an exception or hash" do
@@ -133,7 +133,7 @@ class NoticeTest < Test::Unit::TestCase
   end
 
   should "set sensible defaults without an exception" do
-    backtrace = HoptoadNotifier::Backtrace.parse(build_backtrace_array)
+    backtrace = ErrornotNotifier::Backtrace.parse(build_backtrace_array)
     notice = build_notice(:backtrace => build_backtrace_array)
 
     assert_equal 'Notification', notice.error_message
@@ -143,8 +143,8 @@ class NoticeTest < Test::Unit::TestCase
   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)
+    filters = ErrornotNotifier::Configuration.new.backtrace_filters
+    backtrace = ErrornotNotifier::Backtrace.parse(caller, :filters => filters)
     notice = build_notice(:exception => StandardError.new('error'), :backtrace => nil)
 
     assert_array_starts_with backtrace.lines, notice.backtrace.lines
@@ -166,7 +166,7 @@ class NoticeTest < Test::Unit::TestCase
 
   context "a Notice turned into XML" do
     setup do
-      HoptoadNotifier.configure do |config|
+      ErrornotNotifier.configure do |config|
         config.api_key = "1234567890"
       end
 

data/test/notifier_test.rb

@@ -16,48 +16,48 @@ class NotifierTest < Test::Unit::TestCase
   end
 
   def assert_sent(notice, notice_args)
-    assert_received(HoptoadNotifier::Notice, :new) {|expect| expect.with(has_entries(notice_args)) }
+    assert_received(ErrornotNotifier::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) }
+    assert_received(ErrornotNotifier.sender, :send_to_errornot) {|expect| expect.with(notice.to_xml) }
   end
 
   def set_public_env
-    HoptoadNotifier.configure { |config| config.environment_name = 'production' }
+    ErrornotNotifier.configure { |config| config.environment_name = 'production' }
   end
 
   def set_development_env
-    HoptoadNotifier.configure { |config| config.environment_name = 'development' }
+    ErrornotNotifier.configure { |config| config.environment_name = 'development' }
   end
 
   should "yield and save a configuration when configuring" do
     yielded_configuration = nil
-    HoptoadNotifier.configure do |config|
+    ErrornotNotifier.configure do |config|
       yielded_configuration = config
     end
 
-    assert_kind_of HoptoadNotifier::Configuration, yielded_configuration
-    assert_equal yielded_configuration, HoptoadNotifier.configuration
+    assert_kind_of ErrornotNotifier::Configuration, yielded_configuration
+    assert_equal yielded_configuration, ErrornotNotifier.configuration
   end
 
   should "not remove existing config options when configuring twice" do
     first_config = nil
-    HoptoadNotifier.configure do |config|
+    ErrornotNotifier.configure do |config|
       first_config = config
     end
-    HoptoadNotifier.configure do |config|
+    ErrornotNotifier.configure do |config|
       assert_equal first_config, config
     end
   end
 
   should "configure the sender" do
     sender = stub_sender
-    HoptoadNotifier::Sender.stubs(:new => sender)
+    ErrornotNotifier::Sender.stubs(:new => sender)
     configuration = nil
 
-    HoptoadNotifier.configure { |yielded_config| configuration = yielded_config }
+    ErrornotNotifier.configure { |yielded_config| configuration = yielded_config }
 
-    assert_received(HoptoadNotifier::Sender, :new) { |expect| expect.with(configuration) }
-    assert_equal sender, HoptoadNotifier.sender
+    assert_received(ErrornotNotifier::Sender, :new) { |expect| expect.with(configuration) }
+    assert_equal sender, ErrornotNotifier.sender
   end
 
   should "create and send a notice for an exception" do
@@ -66,7 +66,7 @@ class NotifierTest < Test::Unit::TestCase
     stub_sender!
     notice = stub_notice!
 
-    HoptoadNotifier.notify(exception)
+    ErrornotNotifier.notify(exception)
 
     assert_sent notice, :exception => exception
   end
@@ -77,7 +77,7 @@ class NotifierTest < Test::Unit::TestCase
     notice_args = { :error_message => 'uh oh' }
     stub_sender!
 
-    HoptoadNotifier.notify(notice_args)
+    ErrornotNotifier.notify(notice_args)
 
     assert_sent(notice, notice_args)
   end
@@ -89,7 +89,7 @@ class NotifierTest < Test::Unit::TestCase
     notice_args = { :error_message => 'uh oh' }
     stub_sender!
 
-    HoptoadNotifier.notify(exception, notice_args)
+    ErrornotNotifier.notify(exception, notice_args)
 
     assert_sent(notice, notice_args.merge(:exception => exception))
   end
@@ -98,10 +98,10 @@ class NotifierTest < Test::Unit::TestCase
     set_development_env
     sender = stub_sender!
 
-    HoptoadNotifier.notify(build_exception)
-    HoptoadNotifier.notify_or_ignore(build_exception)
+    ErrornotNotifier.notify(build_exception)
+    ErrornotNotifier.notify_or_ignore(build_exception)
 
-    assert_received(sender, :send_to_hoptoad) {|expect| expect.never }
+    assert_received(sender, :send_to_errornot) {|expect| expect.never }
   end
 
   should "not deliver an ignored exception when notifying implicitly" do
@@ -111,9 +111,9 @@ class NotifierTest < Test::Unit::TestCase
     notice = stub_notice!
     notice.stubs(:ignore? => true)
 
-    HoptoadNotifier.notify_or_ignore(exception)
+    ErrornotNotifier.notify_or_ignore(exception)
 
-    assert_received(sender, :send_to_hoptoad) {|expect| expect.never }
+    assert_received(sender, :send_to_errornot) {|expect| expect.never }
   end
 
   should "deliver an ignored exception when notifying manually" do
@@ -123,7 +123,7 @@ class NotifierTest < Test::Unit::TestCase
     notice = stub_notice!
     notice.stubs(:ignore? => true)
 
-    HoptoadNotifier.notify(exception)
+    ErrornotNotifier.notify(exception)
 
     assert_sent(notice, :exception => exception)
   end
@@ -133,11 +133,11 @@ class NotifierTest < Test::Unit::TestCase
     config_opts = { 'one' => 'two', 'three' => 'four' }
     notice = stub_notice!
     stub_sender!
-    HoptoadNotifier.configuration = stub('config', :merge => config_opts, :public? => true)
+    ErrornotNotifier.configuration = stub('config', :merge => config_opts, :public? => true)
 
-    HoptoadNotifier.notify(exception)
+    ErrornotNotifier.notify(exception)
 
-    assert_received(HoptoadNotifier::Notice, :new) do |expect|
+    assert_received(ErrornotNotifier::Notice, :new) do |expect|
       expect.with(has_entries(config_opts))
     end
   end
@@ -146,7 +146,7 @@ class NotifierTest < Test::Unit::TestCase
     setup do
       @params    = { :controller => "users", :action => "create" }
       @exception = build_exception
-      @hash      = HoptoadNotifier.build_lookup_hash_for(@exception, @params)
+      @hash      = ErrornotNotifier.build_lookup_hash_for(@exception, @params)
     end
 
     should "set action" do
@@ -176,14 +176,14 @@ class NotifierTest < Test::Unit::TestCase
     should "not set file or line number with no backtrace" do
       @exception.stubs(:backtrace).returns([])
 
-      @hash = HoptoadNotifier.build_lookup_hash_for(@exception)
+      @hash = ErrornotNotifier.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)
+      @hash = ErrornotNotifier.build_lookup_hash_for(@exception)
 
       assert_nil @hash[:action]
       assert_nil @hash[:controller]
@@ -199,7 +199,7 @@ class NotifierTest < Test::Unit::TestCase
       end
 
       should "unwrap exceptions that provide #original_exception" do
-        @hash = HoptoadNotifier.build_lookup_hash_for(@exception)
+        @hash = ErrornotNotifier.build_lookup_hash_for(@exception)
         assert_equal "NotifierTest::OriginalException", @hash[:error_class]
       end
     end
@@ -214,7 +214,7 @@ class NotifierTest < Test::Unit::TestCase
       end
 
       should "unwrap exceptions that provide #continued_exception" do
-        @hash = HoptoadNotifier.build_lookup_hash_for(@exception)
+        @hash = ErrornotNotifier.build_lookup_hash_for(@exception)
         assert_equal "NotifierTest::ContinuedException", @hash[:error_class]
       end
     end

data/test/rack_test.rb

@@ -5,7 +5,7 @@ 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)
+    stack = ErrornotNotifier::Rack.new(app)
 
     response = stack.call(environment)
 
@@ -13,7 +13,7 @@ class RackTest < Test::Unit::TestCase
   end
 
   should "deliver an exception raised while calling an upstream app" do
-    HoptoadNotifier.stubs(:notify_or_ignore)
+    ErrornotNotifier.stubs(:notify_or_ignore)
 
     exception = build_exception
     environment = { 'key' => 'value' }
@@ -22,7 +22,7 @@ class RackTest < Test::Unit::TestCase
     end
 
     begin
-      stack = HoptoadNotifier::Rack.new(app)
+      stack = ErrornotNotifier::Rack.new(app)
       stack.call(environment)
     rescue Exception => raised
       assert_equal exception, raised
@@ -30,13 +30,13 @@ class RackTest < Test::Unit::TestCase
       flunk "Didn't raise an exception"
     end
 
-    assert_received(HoptoadNotifier, :notify_or_ignore) do |expect|
+    assert_received(ErrornotNotifier, :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)
+    ErrornotNotifier.stubs(:notify_or_ignore)
     exception = build_exception
     environment = { 'key' => 'value' }
 
@@ -45,12 +45,12 @@ class RackTest < Test::Unit::TestCase
       env['rack.exception'] = exception
       response
     end
-    stack = HoptoadNotifier::Rack.new(app)
+    stack = ErrornotNotifier::Rack.new(app)
 
     actual_response = stack.call(environment)
 
     assert_equal response, actual_response
-    assert_received(HoptoadNotifier, :notify_or_ignore) do |expect|
+    assert_received(ErrornotNotifier, :notify_or_ignore) do |expect|
       expect.with(exception, :rack_env => environment)
     end
   end

data/test/rails_initializer_test.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/helper'
 
-require 'hoptoad_notifier/rails'
+require 'errornot_notifier/rails'
 
 class RailsInitializerTest < Test::Unit::TestCase
   include DefinesConstants
@@ -12,25 +12,25 @@ class RailsInitializerTest < Test::Unit::TestCase
       end
     end
     define_constant("Rails", rails)
-    HoptoadNotifier::Rails.initialize
-    assert_equal "RAILS LOGGER", HoptoadNotifier.logger
+    ErrornotNotifier::Rails.initialize
+    assert_equal "RAILS LOGGER", ErrornotNotifier.logger
   end
 
   should "trigger use of Rails' default logger if logger isn't set and Rails.logger doesn't exist" do
     define_constant("RAILS_DEFAULT_LOGGER", "RAILS DEFAULT LOGGER")
 
-    HoptoadNotifier::Rails.initialize
-    assert_equal "RAILS DEFAULT LOGGER", HoptoadNotifier.logger
+    ErrornotNotifier::Rails.initialize
+    assert_equal "RAILS DEFAULT LOGGER", ErrornotNotifier.logger
   end
 
   should "allow overriding of the logger if already assigned" do
     define_constant("RAILS_DEFAULT_LOGGER", "RAILS DEFAULT LOGGER")
-    HoptoadNotifier::Rails.initialize
+    ErrornotNotifier::Rails.initialize
 
-    HoptoadNotifier.configure(true) do |config|
+    ErrornotNotifier.configure(true) do |config|
       config.logger = "OVERRIDDEN LOGGER"
     end
 
-    assert_equal "OVERRIDDEN LOGGER", HoptoadNotifier.logger
+    assert_equal "OVERRIDDEN LOGGER", ErrornotNotifier.logger
   end
 end

data/test/sender_test.rb

@@ -7,15 +7,16 @@ class SenderTest < Test::Unit::TestCase
   end
 
   def build_sender(opts = {})
-    config = HoptoadNotifier::Configuration.new
+    config = ErrornotNotifier::Configuration.new
+    config.host = 'localhost'
     opts.each {|opt, value| config.send(:"#{opt}=", value) }
-    HoptoadNotifier::Sender.new(config)
+    ErrornotNotifier::Sender.new(config)
   end
 
   def send_exception(args = {})
     notice = args.delete(:notice) || build_notice_data
     sender = args.delete(:sender) || build_sender(args)
-    sender.send_to_hoptoad(notice)
+    sender.send_to_errornot(notice)
     sender
   end
 
@@ -29,7 +30,7 @@ class SenderTest < Test::Unit::TestCase
     http
   end
 
-  should "post to Hoptoad when using an HTTP proxy" do
+  should "post to Errornot when using an HTTP proxy" do
     response = stub(:body => 'body')
     http     = stub(:post          => response,
                     :read_timeout= => nil,
@@ -38,7 +39,7 @@ class SenderTest < Test::Unit::TestCase
     proxy    = stub(:new => http)
     Net::HTTP.stubs(:Proxy => proxy)
 
-    url = "http://hoptoadapp.com:80#{HoptoadNotifier::Sender::NOTICES_URI}"
+    url = "http://hoptoadapp.com:80#{ErrornotNotifier::Sender::NOTICES_URI}"
     uri = URI.parse(url)
 
     proxy_host = 'some.host'
@@ -50,8 +51,8 @@ class SenderTest < Test::Unit::TestCase
                    :proxy_port => proxy_port,
                    :proxy_user => proxy_user,
                    :proxy_pass => proxy_pass)
-    assert_received(http, :post) do |expect| 
-      expect.with(uri.path, anything, HoptoadNotifier::HEADERS)
+    assert_received(http, :post) do |expect|
+      expect.with(uri.path, anything, ErrornotNotifier::HEADERS)
     end
     assert_received(Net::HTTP, :Proxy) do |expect|
       expect.with(proxy_host, proxy_port, proxy_user, proxy_pass)
@@ -60,16 +61,16 @@ class SenderTest < Test::Unit::TestCase
 
   should "post to the right url for non-ssl" do
     http = stub_http
-    url = "http://hoptoadapp.com:80#{HoptoadNotifier::Sender::NOTICES_URI}"
+    url = "http://hoptoadapp.com:80#{ErrornotNotifier::Sender::NOTICES_URI}"
     uri = URI.parse(url)
     send_exception(:secure => false)
-    assert_received(http, :post) {|expect| expect.with(uri.path, anything, HoptoadNotifier::HEADERS) }
+    assert_received(http, :post) {|expect| expect.with(uri.path, anything, ErrornotNotifier::HEADERS) }
   end
 
   should "post to the right path for ssl" do
     http = stub_http
     send_exception(:secure => true)
-    assert_received(http, :post) {|expect| expect.with(HoptoadNotifier::Sender::NOTICES_URI, anything, HoptoadNotifier::HEADERS) }
+    assert_received(http, :post) {|expect| expect.with(ErrornotNotifier::Sender::NOTICES_URI, anything, ErrornotNotifier::HEADERS) }
   end
 
   should "default the open timeout to 2 seconds" do
@@ -99,13 +100,13 @@ class SenderTest < Test::Unit::TestCase
   should "connect to the right port for ssl" do
     stub_http
     send_exception(:secure => true)
-    assert_received(Net::HTTP, :new) {|expect| expect.with("hoptoadapp.com", 443) }
+    assert_received(Net::HTTP, :new) {|expect| expect.with("localhost", 443) }
   end
 
   should "connect to the right port for non-ssl" do
     stub_http
     send_exception(:secure => false)
-    assert_received(Net::HTTP, :new) {|expect| expect.with("hoptoadapp.com", 80) }
+    assert_received(Net::HTTP, :new) {|expect| expect.with("localhost", 80) }
   end
 
   should "use ssl if secure" do