errornot_notifier 0.1.0 → 1.0.0

data/rails/init.rb

@@ -1 +1 @@
-require 'hoptoad_notifier/rails'
+require 'errornot_notifier/rails'

data/script/integration_test.rb

@@ -8,31 +8,31 @@ RAILS_ROOT = FileUtils.pwd
 RAILS_DEFAULT_LOGGER = Logger.new(STDOUT)
 
 $: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'hoptoad_notifier'
+require 'errornot_notifier'
 require 'rails/init'
 
 fail "Please supply an API Key as the first argument" if ARGV.empty?
 
 host = ARGV[1]
-host ||= "hoptoadapp.com"
+raise ArgumentError.new('You need define your Errornot URL like params') unless host
 
 secure = (ARGV[2] == "secure")
 
 exception = begin
-              raise "Testing hoptoad notifier with secure = #{secure}. If you can see this, it works."
+              raise "Testing errornot notifier with secure = #{secure}. If you can see this, it works."
             rescue => foo
               foo
             end
 
-HoptoadNotifier.configure do |config|
+ErrornotNotifier.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|
+ErrornotNotifier.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)
+ErrornotNotifier.notify(exception)
 

data/test/backtrace_test.rb

@@ -8,7 +8,7 @@ class BacktraceTest < Test::Unit::TestCase
       "app/controllers/users_controller.rb:8:in `index'"
     ]
 
-    backtrace = HoptoadNotifier::Backtrace.parse(array)
+    backtrace = ErrornotNotifier::Backtrace.parse(array)
 
     line = backtrace.lines.first
     assert_equal '13', line.number
@@ -26,13 +26,13 @@ class BacktraceTest < Test::Unit::TestCase
     two = one.dup
     assert_equal one, two
 
-    assert_equal HoptoadNotifier::Backtrace.parse(one), HoptoadNotifier::Backtrace.parse(two)
+    assert_equal ErrornotNotifier::Backtrace.parse(one), ErrornotNotifier::Backtrace.parse(two)
   end
 
   should "parse massive one-line exceptions into multiple lines" do
-    original_backtrace = HoptoadNotifier::Backtrace.
+    original_backtrace = ErrornotNotifier::Backtrace.
       parse(["one:1:in `one'\n   two:2:in `two'\n      three:3:in `three`"])
-    expected_backtrace = HoptoadNotifier::Backtrace.
+    expected_backtrace = ErrornotNotifier::Backtrace.
       parse(["one:1:in `one'", "two:2:in `two'", "three:3:in `three`"])
 
     assert_equal expected_backtrace, original_backtrace
@@ -41,7 +41,7 @@ class BacktraceTest < Test::Unit::TestCase
   context "with a project root" do
     setup do
       @project_root = '/some/path'
-      HoptoadNotifier.configure {|config| config.project_root = @project_root }
+      ErrornotNotifier.configure {|config| config.project_root = @project_root }
     end
 
     teardown do
@@ -49,12 +49,12 @@ class BacktraceTest < Test::Unit::TestCase
     end
 
     should "filter out the project root" do
-      backtrace_with_root = HoptoadNotifier::Backtrace.parse(
+      backtrace_with_root = ErrornotNotifier::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(
+      backtrace_without_root = ErrornotNotifier::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'"])
@@ -65,7 +65,7 @@ class BacktraceTest < Test::Unit::TestCase
 
   context "with a blank project root" do
     setup do
-      HoptoadNotifier.configure {|config| config.project_root = '' }
+      ErrornotNotifier.configure {|config| config.project_root = '' }
     end
 
     teardown do
@@ -78,21 +78,21 @@ class BacktraceTest < Test::Unit::TestCase
                    "/lib/something.rb:41:in `open'"]
 
       backtrace_with_root =
-        HoptoadNotifier::Backtrace.parse(backtrace, :filters => default_filters)
+        ErrornotNotifier::Backtrace.parse(backtrace, :filters => default_filters)
 
       backtrace_without_root =
-        HoptoadNotifier::Backtrace.parse(backtrace)
+        ErrornotNotifier::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`']
+    inside_notifier  = ['lib/errornot_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,
+    without_inside = ErrornotNotifier::Backtrace.parse(outside_notifier)
+    with_inside    = ErrornotNotifier::Backtrace.parse(inside_notifier + outside_notifier,
                                                       :filters => default_filters)
 
     assert_equal without_inside, with_inside
@@ -100,9 +100,9 @@ class BacktraceTest < Test::Unit::TestCase
 
   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'"],
+    input = ErrornotNotifier::Backtrace.parse(["foo:13:in `one'", "baz:14:in `two'"],
                                              :filters => filters)
-    expected = HoptoadNotifier::Backtrace.parse(["bar:13:in `one'", "baz:14:in `two'"])
+    expected = ErrornotNotifier::Backtrace.parse(["bar:13:in `one'", "baz:14:in `two'"])
     assert_equal expected, input
   end
 
@@ -112,7 +112,7 @@ class BacktraceTest < Test::Unit::TestCase
   end
 
   def default_filters
-    HoptoadNotifier::Configuration::DEFAULT_BACKTRACE_FILTERS
+    ErrornotNotifier::Configuration::DEFAULT_BACKTRACE_FILTERS
   end
 
 end

data/test/catcher_test.rb

@@ -7,19 +7,19 @@ class ActionControllerCatcherTest < Test::Unit::TestCase
   def setup
     super
     reset_config
-    HoptoadNotifier.sender = CollectingSender.new
+    ErrornotNotifier.sender = CollectingSender.new
     define_constant('RAILS_ROOT', '/path/to/rails/root')
   end
 
   def ignore(exception_class)
-    HoptoadNotifier.configuration.ignore << exception_class
+    ErrornotNotifier.configuration.ignore << exception_class
   end
 
   def build_controller_class(&definition)
     returning Class.new(ActionController::Base) do |klass|
-      klass.__send__(:include, HoptoadNotifier::Rails::ActionControllerCatcher)
+      klass.__send__(:include, ErrornotNotifier::Rails::ActionControllerCatcher)
       klass.class_eval(&definition) if definition
-      define_constant('HoptoadTestController', klass)
+      define_constant('ErrornotTestController', klass)
     end
   end
 
@@ -44,7 +44,7 @@ class ActionControllerCatcherTest < Test::Unit::TestCase
   end
 
   def sender
-    HoptoadNotifier.sender
+    ErrornotNotifier.sender
   end
 
   def last_sent_notice_xml
@@ -82,7 +82,7 @@ class ActionControllerCatcherTest < Test::Unit::TestCase
     klass.consider_all_requests_local = opts[:all_local]
     klass.local                       = opts[:local]
     controller = klass.new
-    controller.stubs(:rescue_action_in_public_without_hoptoad)
+    controller.stubs(:rescue_action_in_public_without_errornot)
     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])
@@ -91,7 +91,7 @@ class ActionControllerCatcherTest < Test::Unit::TestCase
 
   def process_action_with_manual_notification(args = {})
     process_action(args) do
-      notify_hoptoad(:error_message => 'fail')
+      notify_errornot(:error_message => 'fail')
       # Rails will raise a template error if we don't render something
       render :nothing => true
     end
@@ -152,28 +152,28 @@ class ActionControllerCatcherTest < Test::Unit::TestCase
   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)
+    assert_received(controller, :rescue_action_in_public_without_errornot)
   end
 
-  should "not create actions from Hoptoad methods" do
+  should "not create actions from Errornot methods" do
     controller = build_controller_class.new
-    assert_equal [], HoptoadNotifier::Rails::ActionControllerCatcher.instance_methods
+    assert_equal [], ErrornotNotifier::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/]
+    ErrornotNotifier.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']
+    ErrornotNotifier.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']
+    ErrornotNotifier.configuration.ignore_user_agent_only = ['IgnoredUserAgent']
     process_action_with_automatic_notification(:user_agent => 'NonIgnoredAgent')
     assert_caught_and_sent
   end
@@ -191,25 +191,25 @@ class ActionControllerCatcherTest < Test::Unit::TestCase
   end
 
   should "send request data for manual notification" do
-    params = { 'controller' => "hoptoad_test", 'action' => "index" }
+    params = { 'controller' => "errornot_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" }
+    params = { 'controller' => "errornot_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" }
+    params = { 'controller' => "errornot_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" }
+    params = { 'controller' => "errornot_test", 'action' => "index" }
     controller = process_action_with_automatic_notification(:params => params, :port => 81)
     assert_sent_request_info_for controller.request
   end
@@ -233,8 +233,8 @@ class ActionControllerCatcherTest < Test::Unit::TestCase
 
   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 })
+      ErrornotNotifier.configuration.development_lookup = true
+      ErrornotNotifier.stubs(:build_lookup_hash_for).returns({ :awesome => 2 })
 
       @controller = process_action_with_automatic_notification(:local => true)
       @response   = @controller.response
@@ -246,15 +246,15 @@ class ActionControllerCatcherTest < Test::Unit::TestCase
     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 ErrornotNotifier.configuration.host.to_json, @response.body
+      assert_match ErrornotNotifier.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
+      ErrornotNotifier.configuration.development_lookup = false
 
       @controller = process_action_with_automatic_notification(:local => true)
       @response   = @controller.response

data/test/configuration_test.rb

@@ -12,41 +12,39 @@ class ConfigurationTest < Test::Unit::TestCase
     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 :notifier_version,    ErrornotNotifier::VERSION
+    assert_config_default :notifier_name,       'Errornot Notifier'
     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
+                          ErrornotNotifier::Configuration::DEFAULT_PARAMS_FILTERS
     assert_config_default :backtrace_filters,
-                          HoptoadNotifier::Configuration::DEFAULT_BACKTRACE_FILTERS
+                          ErrornotNotifier::Configuration::DEFAULT_BACKTRACE_FILTERS
     assert_config_default :ignore,
-                          HoptoadNotifier::Configuration::IGNORE_DEFAULT
+                          ErrornotNotifier::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 = ErrornotNotifier::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 = ErrornotNotifier::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 = ErrornotNotifier::Configuration.new
     config.secure = false
     config.port
     config.secure = true
@@ -77,7 +75,7 @@ class ConfigurationTest < Test::Unit::TestCase
   end
 
   should "act like a hash" do
-    config = HoptoadNotifier::Configuration.new
+    config = ErrornotNotifier::Configuration.new
     hash = config.to_hash
     [:api_key, :backtrace_filters, :development_environments,
      :environment_name, :host, :http_open_timeout,
@@ -90,7 +88,7 @@ class ConfigurationTest < Test::Unit::TestCase
   end
 
   should "be mergable" do
-    config = HoptoadNotifier::Configuration.new
+    config = ErrornotNotifier::Configuration.new
     hash = config.to_hash
     assert_equal hash.merge(:key => 'value'), config.merge(:key => 'value')
   end
@@ -100,7 +98,7 @@ class ConfigurationTest < Test::Unit::TestCase
   end
 
   should "warn when attempting to read environment filters" do
-    config = HoptoadNotifier::Configuration.new
+    config = ErrornotNotifier::Configuration.new
     config.
       expects(:warn).
       with(regexp_matches(/deprecated/i))
@@ -128,7 +126,7 @@ class ConfigurationTest < Test::Unit::TestCase
   end
 
   should "allow ignored exceptions to be appended" do
-    config = HoptoadNotifier::Configuration.new
+    config = ErrornotNotifier::Configuration.new
     original_filters = config.ignore.dup
     new_filter = 'hello'
     config.ignore << new_filter
@@ -144,48 +142,48 @@ class ConfigurationTest < Test::Unit::TestCase
   end
 
   should "use development and test as development environments by default" do
-    config = HoptoadNotifier::Configuration.new
+    config = ErrornotNotifier::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 = ErrornotNotifier::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 = ErrornotNotifier::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
+    config = ErrornotNotifier::Configuration.new
     assert config.public?
   end
 
   should "use the assigned logger if set" do
-    config = HoptoadNotifier::Configuration.new
+    config = ErrornotNotifier::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
+    config ||= ErrornotNotifier::Configuration.new
     assert_equal default_value, config.send(option)
   end
 
   def assert_config_overridable(option, value = 'a value')
-    config = HoptoadNotifier::Configuration.new
+    config = ErrornotNotifier::Configuration.new
     config.send(:"#{option}=", value)
     assert_equal value, config.send(option)
   end
 
   def assert_appends_value(option, &block)
-    config = HoptoadNotifier::Configuration.new
+    config = ErrornotNotifier::Configuration.new
     original_values = config.send(option).dup
     block ||= lambda do |config|
       new_value = 'hello'
@@ -197,7 +195,7 @@ class ConfigurationTest < Test::Unit::TestCase
   end
 
   def assert_replaces(option, setter)
-    config = HoptoadNotifier::Configuration.new
+    config = ErrornotNotifier::Configuration.new
     new_value = 'hello'
     config.send(setter, [new_value])
     assert_equal [new_value], config.send(option)

data/test/erronot_tasks_test.rb

@@ -0,0 +1,147 @@
+require File.dirname(__FILE__) + '/helper'
+require 'rubygems'
+
+require File.dirname(__FILE__) + '/../lib/errornot_tasks'
+require 'fakeweb'
+
+FakeWeb.allow_net_connect = false
+
+class ErrornotTasksTest < Test::Unit::TestCase
+  def test_assert
+    assert true
+  end
+  # TODO: reactivate spec when it's implement
+  #def successful_response(body = "")
+    #response = Net::HTTPSuccess.new('1.2', '200', 'OK')
+    #response.stubs(:body).returns(body)
+    #return response
+  #end
+
+  #def unsuccessful_response(body = "")
+    #response = Net::HTTPClientError.new('1.2', '200', 'OK')
+    #response.stubs(:body).returns(body)
+    #return response
+  #end
+
+  #context "being quiet" do
+    #setup { ErrornotTasks.stubs(:puts) }
+
+    #context "in a configured project" do
+      #setup {
+        #ErrornotNotifier.configure { |config|
+          #config.host = 'localhost'
+          #config.api_key = "1234123412341234"
+        #}
+      #}
+
+      #context "on deploy({})" do
+        #setup { @output = ErrornotTasks.deploy({}) }
+
+        #before_should "complain about missing rails env" do
+          #ErrornotTasks.expects(:puts).with(regexp_matches(/rails environment/i))
+        #end
+
+        #should "return false" do
+          #assert !@output
+        #end
+      #end
+
+      #context "given valid options" do
+        #setup { @options = {:rails_env => "staging"} }
+
+        #context "on deploy(options)" do
+          #setup { @output = ErrornotTasks.deploy(@options) }
+
+          #before_should "post to http://errornotapp.com/deploys.txt" do
+            #URI.stubs(:parse).with('http://errornotapp.com/deploys.txt').returns(:uri)
+            #Net::HTTP.expects(:post_form).with(:uri, kind_of(Hash)).returns(successful_response)
+          #end
+
+          #before_should "use the project api key" do
+            #Net::HTTP.expects(:post_form).
+              #with(kind_of(URI), has_entries('api_key' => "1234123412341234")).
+              #returns(successful_response)
+          #end
+
+          #before_should "use send the rails_env param" do
+            #Net::HTTP.expects(:post_form).
+              #with(kind_of(URI), has_entries("deploy[rails_env]" => "staging")).
+              #returns(successful_response)
+          #end
+
+          #[:local_username, :scm_repository, :scm_revision].each do |key|
+            #before_should "use send the #{key} param if it's passed in." do
+              #@options[key] = "value"
+              #Net::HTTP.expects(:post_form).
+                #with(kind_of(URI), has_entries("deploy[#{key}]" => "value")).
+                #returns(successful_response)
+            #end
+          #end
+
+          #before_should "use the :api_key param if it's passed in." do
+            #@options[:api_key] = "value"
+            #Net::HTTP.expects(:post_form).
+              #with(kind_of(URI), has_entries("api_key" => "value")).
+              #returns(successful_response)
+          #end
+
+          #before_should "puts the response body on success" do
+            #ErrornotTasks.expects(:puts).with("body")
+            #Net::HTTP.expects(:post_form).with(any_parameters).returns(successful_response('body'))
+          #end
+
+          #before_should "puts the response body on failure" do
+            #ErrornotTasks.expects(:puts).with("body")
+            #Net::HTTP.expects(:post_form).with(any_parameters).returns(unsuccessful_response('body'))
+          #end
+
+          #should "return false on failure", :before => lambda {
+            #Net::HTTP.expects(:post_form).with(any_parameters).returns(unsuccessful_response('body'))
+          #} do
+            #assert !@output
+          #end
+
+          #should "return true on success", :before => lambda {
+            #Net::HTTP.expects(:post_form).with(any_parameters).returns(successful_response('body'))
+          #} do
+            #assert @output
+          #end
+        #end
+      #end
+    #end
+
+    #context "in a configured project with custom host" do
+      #setup do
+        #ErrornotNotifier.configure do |config|
+          #config.api_key = "1234123412341234"
+          #config.host = "custom.host"
+        #end
+      #end
+
+      #context "on deploy(:rails_env => 'staging')" do
+        #setup { @output = ErrornotTasks.deploy(:rails_env => "staging") }
+
+        #before_should "post to the custom host" do
+          #URI.stubs(:parse).with('http://custom.host/deploys.txt').returns(:uri)
+          #Net::HTTP.expects(:post_form).with(:uri, kind_of(Hash)).returns(successful_response)
+        #end
+      #end
+    #end
+
+    #context "when not configured" do
+      #setup { ErrornotNotifier.configure { |config| config.api_key = "" } }
+
+      #context "on deploy(:rails_env => 'staging')" do
+        #setup { @output = ErrornotTasks.deploy(:rails_env => "staging") }
+
+        #before_should "complain about missing api key" do
+          #ErrornotTasks.expects(:puts).with(regexp_matches(/api key/i))
+        #end
+
+        #should "return false" do
+          #assert !@output
+        #end
+      #end
+    #end
+  #end
+end