exception_notification 4.3.0 → 4.5.0

data/test/exception_notifier/teams_notifier_test.rb

@@ -1,20 +1,21 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'httparty'
 
 class TeamsNotifierTest < ActiveSupport::TestCase
-
-  test "should send notification if properly configured" do
+  test 'should send notification if properly configured' do
     options = {
-      :webhook_url => 'http://localhost:8000'
+      webhook_url: 'http://localhost:8000'
     }
     teams_notifier = ExceptionNotifier::TeamsNotifier.new
     teams_notifier.httparty = FakeHTTParty.new
 
-    options = teams_notifier.call ArgumentError.new("foo"), options
+    options = teams_notifier.call ArgumentError.new('foo'), options
 
     body = ActiveSupport::JSON.decode options[:body]
-    assert body.has_key? 'title'
-    assert body.has_key? 'sections'
+    assert body.key? 'title'
+    assert body.key? 'sections'
 
     sections = body['sections']
     header = sections[0]
@@ -24,15 +25,15 @@ class TeamsNotifierTest < ActiveSupport::TestCase
     assert_equal 'foo', header['activitySubtitle']
   end
 
-  test "should send notification with create gitlab issue link if specified" do
+  test 'should send notification with create gitlab issue link if specified' do
     options = {
-      :webhook_url => 'http://localhost:8000',
-      :git_url => 'github.com/aschen'
+      webhook_url: 'http://localhost:8000',
+      git_url: 'github.com/aschen'
     }
     teams_notifier = ExceptionNotifier::TeamsNotifier.new
     teams_notifier.httparty = FakeHTTParty.new
 
-    options = teams_notifier.call ArgumentError.new("foo"), options
+    options = teams_notifier.call ArgumentError.new('foo'), options
 
     body = ActiveSupport::JSON.decode options[:body]
 
@@ -44,27 +45,27 @@ class TeamsNotifierTest < ActiveSupport::TestCase
 
   test 'should add other HTTParty options to params' do
     options = {
-      :webhook_url => 'http://localhost:8000',
-      :username => "Test Bot",
-      :avatar => 'http://site.com/icon.png',
-      :basic_auth => {
-        :username => 'clara',
-        :password => 'password'
+      webhook_url: 'http://localhost:8000',
+      username: 'Test Bot',
+      avatar: 'http://site.com/icon.png',
+      basic_auth: {
+        username: 'clara',
+        password: 'password'
       }
     }
     teams_notifier = ExceptionNotifier::TeamsNotifier.new
     teams_notifier.httparty = FakeHTTParty.new
 
-    options = teams_notifier.call ArgumentError.new("foo"), options
+    options = teams_notifier.call ArgumentError.new('foo'), options
 
-    assert options.has_key? :basic_auth
+    assert options.key? :basic_auth
     assert 'clara', options[:basic_auth][:username]
     assert 'password', options[:basic_auth][:password]
   end
 
   test "should use 'A' for exceptions count if :accumulated_errors_count option is nil" do
     teams_notifier = ExceptionNotifier::TeamsNotifier.new
-    exception = ArgumentError.new("foo")
+    exception = ArgumentError.new('foo')
     teams_notifier.instance_variable_set(:@exception, exception)
     teams_notifier.instance_variable_set(:@options, {})
 
@@ -73,11 +74,11 @@ class TeamsNotifierTest < ActiveSupport::TestCase
     assert_equal 'A *ArgumentError* occurred.', header['activityTitle']
   end
 
-  test "should use direct errors count if :accumulated_errors_count option is 5" do
+  test 'should use direct errors count if :accumulated_errors_count option is 5' do
     teams_notifier = ExceptionNotifier::TeamsNotifier.new
-    exception = ArgumentError.new("foo")
+    exception = ArgumentError.new('foo')
     teams_notifier.instance_variable_set(:@exception, exception)
-    teams_notifier.instance_variable_set(:@options, { accumulated_errors_count: 5 })
+    teams_notifier.instance_variable_set(:@options, accumulated_errors_count: 5)
     message_text = teams_notifier.send(:message_text)
     header = message_text['sections'][0]
     assert_equal '5 *ArgumentError* occurred.', header['activityTitle']
@@ -85,9 +86,7 @@ class TeamsNotifierTest < ActiveSupport::TestCase
 end
 
 class FakeHTTParty
-
-  def post(url, options)
-    return options
+  def post(_url, options)
+    options
   end
-
 end

data/test/exception_notifier/webhook_notifier_test.rb

@@ -1,43 +1,44 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'httparty'
 
 class WebhookNotifierTest < ActiveSupport::TestCase
-
-  test "should send webhook notification if properly configured" do
+  test 'should send webhook notification if properly configured' do
     ExceptionNotifier::WebhookNotifier.stubs(:new).returns(Object.new)
-    webhook = ExceptionNotifier::WebhookNotifier.new({:url => 'http://localhost:8000'})
+    webhook = ExceptionNotifier::WebhookNotifier.new(url: 'http://localhost:8000')
     webhook.stubs(:call).returns(fake_response)
     response = webhook.call(fake_exception)
 
     refute_nil response
     assert_equal response[:status], 200
-    assert_equal response[:body][:exception][:error_class], "ZeroDivisionError"
-    assert_includes response[:body][:exception][:message], "divided by 0"
-    assert_includes response[:body][:exception][:backtrace], "/exception_notification/test/webhook_notifier_test.rb:48"
+    assert_equal response[:body][:exception][:error_class], 'ZeroDivisionError'
+    assert_includes response[:body][:exception][:message], 'divided by 0'
+    assert_includes response[:body][:exception][:backtrace], '/exception_notification/test/webhook_notifier_test.rb:48'
 
-    assert response[:body][:request][:cookies].has_key?(:cookie_item1)
-    assert_equal response[:body][:request][:url], "http://example.com/example"
-    assert_equal response[:body][:request][:ip_address], "192.168.1.1"
-    assert response[:body][:request][:environment].has_key?(:env_item1)
-    assert_equal response[:body][:request][:controller], "#<ControllerName:0x007f9642a04d00>"
-    assert response[:body][:request][:session].has_key?(:session_item1)
-    assert response[:body][:request][:parameters].has_key?(:controller)
-    assert response[:body][:data][:extra_data].has_key?(:data_item1)
+    assert response[:body][:request][:cookies].key?(:cookie_item1)
+    assert_equal response[:body][:request][:url], 'http://example.com/example'
+    assert_equal response[:body][:request][:ip_address], '192.168.1.1'
+    assert response[:body][:request][:environment].key?(:env_item1)
+    assert_equal response[:body][:request][:controller], '#<ControllerName:0x007f9642a04d00>'
+    assert response[:body][:request][:session].key?(:session_item1)
+    assert response[:body][:request][:parameters].key?(:controller)
+    assert response[:body][:data][:extra_data].key?(:data_item1)
   end
 
-  test "should send webhook notification with correct params data" do
+  test 'should send webhook notification with correct params data' do
     url = 'http://localhost:8000'
     fake_exception.stubs(:backtrace).returns('the backtrace')
-    webhook = ExceptionNotifier::WebhookNotifier.new({:url => url})
+    webhook = ExceptionNotifier::WebhookNotifier.new(url: url)
 
     HTTParty.expects(:send).with(:post, url, fake_params)
 
     webhook.call(fake_exception)
   end
 
-  test "should call pre/post_callback if specified" do
+  test 'should call pre/post_callback if specified' do
     HTTParty.stubs(:send).returns(fake_response)
-    webhook = ExceptionNotifier::WebhookNotifier.new({:url => 'http://localhost:8000'})
+    webhook = ExceptionNotifier::WebhookNotifier.new(url: 'http://localhost:8000')
     webhook.call(fake_exception)
   end
 
@@ -45,50 +46,53 @@ class WebhookNotifierTest < ActiveSupport::TestCase
 
   def fake_response
     {
-      :status => 200,
-      :body => {
-        :exception => {
-          :error_class => 'ZeroDivisionError',
-          :message => 'divided by 0',
-          :backtrace => '/exception_notification/test/webhook_notifier_test.rb:48:in `/'
+      status: 200,
+      body: {
+        exception: {
+          error_class: 'ZeroDivisionError',
+          message: 'divided by 0',
+          backtrace: '/exception_notification/test/webhook_notifier_test.rb:48:in `/'
         },
-        :data => {
-          :extra_data => {:data_item1 => "datavalue1", :data_item2 => "datavalue2"}
+        data: {
+          extra_data: { data_item1: 'datavalue1', data_item2: 'datavalue2' }
         },
-        :request => {
-          :cookies => {:cookie_item1 => 'cookieitemvalue1', :cookie_item2 => 'cookieitemvalue2'},
-          :url => 'http://example.com/example',
-          :ip_address => '192.168.1.1',
-          :environment => {:env_item1 => "envitem1", :env_item2 => "envitem2"},
-          :controller => '#<ControllerName:0x007f9642a04d00>',
-          :session => {:session_item1 => "sessionitem1", :session_item2 => "sessionitem2"},
-          :parameters => {:action =>"index", :controller =>"projects"}
+        request: {
+          cookies: { cookie_item1: 'cookieitemvalue1', cookie_item2: 'cookieitemvalue2' },
+          url: 'http://example.com/example',
+          ip_address: '192.168.1.1',
+          environment: { env_item1: 'envitem1', env_item2: 'envitem2' },
+          controller: '#<ControllerName:0x007f9642a04d00>',
+          session: { session_item1: 'sessionitem1', session_item2: 'sessionitem2' },
+          parameters: { action: 'index', controller: 'projects' }
         }
       }
     }
   end
 
   def fake_params
-    {
-      :body => {
-        :server => Socket.gethostname,
-        :process => $$,
-        :rails_root => Rails.root,
-        :exception => {
-          :error_class => 'ZeroDivisionError',
-          :message => 'divided by 0'.inspect,
-          :backtrace => 'the backtrace'
+    params = {
+      body: {
+        server: Socket.gethostname,
+        process: $PROCESS_ID,
+        exception: {
+          error_class: 'ZeroDivisionError',
+          message: 'divided by 0'.inspect,
+          backtrace: 'the backtrace'
         },
-        :data => {}
+        data: {}
       }
     }
+
+    params[:body][:rails_root] = Rails.root if defined?(::Rails) && Rails.respond_to?(:root)
+
+    params
   end
 
   def fake_exception
     @fake_exception ||= begin
-      5/0
-    rescue Exception => e
-      e
-    end
+                          5 / 0
+                        rescue StandardError => e
+                          e
+                        end
   end
 end

data/test/exception_notifier_test.rb

@@ -1,44 +1,48 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
-class ExceptionOne < StandardError;end
-class ExceptionTwo < StandardError;end
+class ExceptionOne < StandardError; end
+class ExceptionTwo < StandardError; end
 
 class ExceptionNotifierTest < ActiveSupport::TestCase
   setup do
+    ExceptionNotifier.register_exception_notifier(:email, exception_recipients: %w[dummyexceptions@example.com])
+
     @notifier_calls = 0
-    @test_notifier = lambda { |exception, options| @notifier_calls += 1 }
+    @test_notifier = ->(_exception, _options) { @notifier_calls += 1 }
   end
 
   teardown do
-    ExceptionNotifier.error_grouping = false
-    ExceptionNotifier.notification_trigger = nil
-    ExceptionNotifier.class_eval("@@notifiers.delete_if { |k, _| k.to_s != \"email\"}")  # reset notifiers
-    Rails.cache.clear
+    ExceptionNotifier.reset_notifiers!
+
+    Rails.cache.clear if defined?(Rails) && Rails.respond_to?(:cache)
   end
 
-  test "should have default ignored exceptions" do
+  test 'should have default ignored exceptions' do
     assert_equal ExceptionNotifier.ignored_exceptions,
-      ['ActiveRecord::RecordNotFound', 'Mongoid::Errors::DocumentNotFound', 'AbstractController::ActionNotFound',
-       'ActionController::RoutingError', 'ActionController::UnknownFormat', 'ActionController::UrlGenerationError']
+                 ['ActiveRecord::RecordNotFound', 'Mongoid::Errors::DocumentNotFound',
+                  'AbstractController::ActionNotFound', 'ActionController::RoutingError',
+                  'ActionController::UnknownFormat', 'ActionController::UrlGenerationError']
   end
 
-  test "should have email notifier registered" do
+  test 'should have email notifier registered' do
     assert_equal ExceptionNotifier.notifiers, [:email]
   end
 
-  test "should have a valid email notifier" do
+  test 'should have a valid email notifier' do
     @email_notifier = ExceptionNotifier.registered_exception_notifier(:email)
     refute_nil @email_notifier
     assert_equal @email_notifier.class, ExceptionNotifier::EmailNotifier
     assert_respond_to @email_notifier, :call
   end
 
-  test "should allow register/unregister another notifier" do
+  test 'should allow register/unregister another notifier' do
     called = false
-    proc_notifier = lambda { |exception, options| called = true }
+    proc_notifier = ->(_exception, _options) { called = true }
     ExceptionNotifier.register_exception_notifier(:proc, proc_notifier)
 
-    assert_equal ExceptionNotifier.notifiers.sort, [:email, :proc]
+    assert_equal ExceptionNotifier.notifiers.sort, %i[email proc]
 
     exception = StandardError.new
 
@@ -49,27 +53,27 @@ class ExceptionNotifierTest < ActiveSupport::TestCase
     assert_equal ExceptionNotifier.notifiers, [:email]
   end
 
-  test "should allow select notifiers to send error to" do
+  test 'should allow select notifiers to send error to' do
     notifier1_calls = 0
-    notifier1 = lambda { |exception, options| notifier1_calls += 1 }
+    notifier1 = ->(_exception, _options) { notifier1_calls += 1 }
     ExceptionNotifier.register_exception_notifier(:notifier1, notifier1)
 
     notifier2_calls = 0
-    notifier2 = lambda { |exception, options| notifier2_calls += 1 }
+    notifier2 = ->(_exception, _options) { notifier2_calls += 1 }
     ExceptionNotifier.register_exception_notifier(:notifier2, notifier2)
 
-    assert_equal ExceptionNotifier.notifiers.sort, [:email, :notifier1, :notifier2]
+    assert_equal ExceptionNotifier.notifiers.sort, %i[email notifier1 notifier2]
 
     exception = StandardError.new
     ExceptionNotifier.notify_exception(exception)
     assert_equal notifier1_calls, 1
     assert_equal notifier2_calls, 1
 
-    ExceptionNotifier.notify_exception(exception, {:notifiers => :notifier1})
+    ExceptionNotifier.notify_exception(exception, notifiers: :notifier1)
     assert_equal notifier1_calls, 2
     assert_equal notifier2_calls, 1
 
-    ExceptionNotifier.notify_exception(exception, {:notifiers => :notifier2})
+    ExceptionNotifier.notify_exception(exception, notifiers: :notifier2)
     assert_equal notifier1_calls, 2
     assert_equal notifier2_calls, 2
 
@@ -78,39 +82,112 @@ class ExceptionNotifierTest < ActiveSupport::TestCase
     assert_equal ExceptionNotifier.notifiers, [:email]
   end
 
-  test "should ignore exception if satisfies conditional ignore" do
-    env = "production"
-    ExceptionNotifier.ignore_if do |exception, options|
-      env != "production"
+  test 'should ignore exception if satisfies conditional ignore' do
+    env = 'production'
+    ExceptionNotifier.ignore_if do |_exception, _options|
+      env != 'production'
     end
 
     ExceptionNotifier.register_exception_notifier(:test, @test_notifier)
 
     exception = StandardError.new
 
-    ExceptionNotifier.notify_exception(exception, {:notifiers => :test})
+    ExceptionNotifier.notify_exception(exception, notifiers: :test)
     assert_equal @notifier_calls, 1
 
-    env = "development"
-    ExceptionNotifier.notify_exception(exception, {:notifiers => :test})
+    env = 'development'
+    ExceptionNotifier.notify_exception(exception, notifiers: :test)
     assert_equal @notifier_calls, 1
+  end
+
+  test 'should ignore exception if satisfies by-notifier conditional ignore' do
+    notifier1_calls = 0
+    notifier1 = ->(_exception, _options) { notifier1_calls += 1 }
+    ExceptionNotifier.register_exception_notifier(:notifier1, notifier1)
+
+    notifier2_calls = 0
+    notifier2 = ->(_exception, _options) { notifier2_calls += 1 }
+    ExceptionNotifier.register_exception_notifier(:notifier2, notifier2)
+
+    env = 'production'
+    ExceptionNotifier.ignore_notifier_if(:notifier1) do |_exception, _options|
+      env == 'development'
+    end
+    ExceptionNotifier.ignore_notifier_if(:notifier2) do |_exception, _options|
+      env == 'production'
+    end
+
+    exception = StandardError.new
+
+    ExceptionNotifier.notify_exception(exception)
+    assert_equal notifier1_calls, 1
+    assert_equal notifier2_calls, 0
+
+    env = 'development'
+
+    ExceptionNotifier.notify_exception(exception)
+    assert_equal notifier1_calls, 1
+    assert_equal notifier2_calls, 1
+
+    env = 'test'
+
+    ExceptionNotifier.notify_exception(exception)
+    assert_equal notifier1_calls, 2
+    assert_equal notifier2_calls, 2
+  end
+
+  test 'should return false if all the registered notifiers are ignored' do
+    ExceptionNotifier.notifiers.each do |notifier|
+      # make sure to register no other notifiers but the tested ones
+      ExceptionNotifier.unregister_exception_notifier(notifier)
+    end
+
+    ExceptionNotifier.register_exception_notifier(:notifier1, ->(_, _) {})
+    ExceptionNotifier.register_exception_notifier(:notifier2, ->(_, _) {})
+
+    ExceptionNotifier.ignore_notifier_if(:notifier1) do |exception, _options|
+      exception.message =~ /non_critical_error/
+    end
+    ExceptionNotifier.ignore_notifier_if(:notifier2) do |exception, _options|
+      exception.message =~ /non_critical_error/
+    end
+
+    exception = StandardError.new('a non_critical_error occured.')
 
-    ExceptionNotifier.clear_ignore_conditions!
+    refute ExceptionNotifier.notify_exception(exception)
   end
 
-  test "should not send notification if one of ignored exceptions" do
+  test 'should return true if one of the notifiers fires' do
+    ExceptionNotifier.notifiers.each do |notifier|
+      # make sure to register no other notifiers but the tested ones
+      ExceptionNotifier.unregister_exception_notifier(notifier)
+    end
+
+    ExceptionNotifier.register_exception_notifier(:notifier1, ->(_, _) {})
+    ExceptionNotifier.register_exception_notifier(:notifier2, ->(_, _) {})
+
+    ExceptionNotifier.ignore_notifier_if(:notifier1) do |exception, _options|
+      exception.message =~ /non-critical\serror/
+    end
+
+    exception = StandardError.new('a non-critical error occured')
+
+    assert ExceptionNotifier.notify_exception(exception)
+  end
+
+  test 'should not send notification if one of ignored exceptions' do
     ExceptionNotifier.register_exception_notifier(:test, @test_notifier)
 
     exception = StandardError.new
 
-    ExceptionNotifier.notify_exception(exception, {:notifiers => :test})
+    ExceptionNotifier.notify_exception(exception, notifiers: :test)
     assert_equal @notifier_calls, 1
 
-    ExceptionNotifier.notify_exception(exception, {:notifiers => :test, :ignore_exceptions => 'StandardError' })
+    ExceptionNotifier.notify_exception(exception, notifiers: :test, ignore_exceptions: 'StandardError')
     assert_equal @notifier_calls, 1
   end
 
-  test "should not send notification if subclass of one of ignored exceptions" do
+  test 'should not send notification if subclass of one of ignored exceptions' do
     ExceptionNotifier.register_exception_notifier(:test, @test_notifier)
 
     class StandardErrorSubclass < StandardError
@@ -118,16 +195,48 @@ class ExceptionNotifierTest < ActiveSupport::TestCase
 
     exception = StandardErrorSubclass.new
 
-    ExceptionNotifier.notify_exception(exception, {:notifiers => :test})
+    ExceptionNotifier.notify_exception(exception, notifiers: :test)
+    assert_equal @notifier_calls, 1
+
+    ExceptionNotifier.notify_exception(exception, notifiers: :test, ignore_exceptions: 'StandardError')
+    assert_equal @notifier_calls, 1
+  end
+
+  test 'should not send notification if extended module one of ignored exceptions' do
+    ExceptionNotifier.register_exception_notifier(:test, @test_notifier)
+
+    module StandardErrorModule; end
+
+    exception = StandardError.new
+    exception.extend StandardErrorModule
+
+    ExceptionNotifier.notify_exception(exception, notifiers: :test)
+    assert_equal @notifier_calls, 1
+
+    ignore_exceptions = 'ExceptionNotifierTest::StandardErrorModule'
+    ExceptionNotifier.notify_exception(exception, notifiers: :test, ignore_exceptions: ignore_exceptions)
+    assert_equal @notifier_calls, 1
+  end
+
+  test 'should not send notification if prepended module at singleton class one of ignored exceptions' do
+    ExceptionNotifier.register_exception_notifier(:test, @test_notifier)
+
+    module StandardErrorModule; end
+
+    exception = StandardError.new
+    exception.singleton_class.prepend StandardErrorModule
+
+    ExceptionNotifier.notify_exception(exception, notifiers: :test)
     assert_equal @notifier_calls, 1
 
-    ExceptionNotifier.notify_exception(exception, {:notifiers => :test, :ignore_exceptions => 'StandardError' })
+    ignore_exceptions = 'ExceptionNotifierTest::StandardErrorModule'
+    ExceptionNotifier.notify_exception(exception, notifiers: :test, ignore_exceptions: ignore_exceptions)
     assert_equal @notifier_calls, 1
   end
 
-  test "should call received block" do
+  test 'should call received block' do
     @block_called = false
-    notifier = lambda { |exception, options, &block| block.call }
+    notifier = ->(_exception, _options, &block) { block.call }
     ExceptionNotifier.register_exception_notifier(:test, notifier)
 
     exception = ExceptionOne.new
@@ -139,7 +248,7 @@ class ExceptionNotifierTest < ActiveSupport::TestCase
     assert @block_called
   end
 
-  test "should not call group_error! or send_notification? if error_grouping false" do
+  test 'should not call group_error! or send_notification? if error_grouping false' do
     exception = StandardError.new
     ExceptionNotifier.expects(:group_error!).never
     ExceptionNotifier.expects(:send_notification?).never
@@ -147,7 +256,7 @@ class ExceptionNotifierTest < ActiveSupport::TestCase
     ExceptionNotifier.notify_exception(exception)
   end
 
-  test "should call group_error! and send_notification? if error_grouping true" do
+  test 'should call group_error! and send_notification? if error_grouping true' do
     ExceptionNotifier.error_grouping = true
 
     exception = StandardError.new
@@ -157,7 +266,7 @@ class ExceptionNotifierTest < ActiveSupport::TestCase
     ExceptionNotifier.notify_exception(exception)
   end
 
-  test "should skip notification if send_notification? is false" do
+  test 'should skip notification if send_notification? is false' do
     ExceptionNotifier.error_grouping = true
 
     exception = StandardError.new
@@ -167,7 +276,7 @@ class ExceptionNotifierTest < ActiveSupport::TestCase
     refute ExceptionNotifier.notify_exception(exception)
   end
 
-  test "should send notification if send_notification? is true" do
+  test 'should send notification if send_notification? is true' do
     ExceptionNotifier.error_grouping = true
 
     exception = StandardError.new

data/test/support/exception_notifier_helper.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# this extension allows ExceptionNotifier to reset all the glocal settings
+# (i.e. class vars that otherwise remains during the test)
+# please remembeer to call this method each time after you set such settings
+# to prevent order dependent test fails.
+module ExceptionNotifier
+  def self.reset_notifiers!
+    @@notifiers = {}
+    clear_ignore_conditions!
+    ExceptionNotifier.error_grouping = false
+    ExceptionNotifier.notification_trigger = nil
+  end
+end

data/test/test_helper.rb

@@ -1,18 +1,19 @@
-# Configure Rails Environment
-ENV["RAILS_ENV"] = "test"
+# frozen_string_literal: true
 
-begin
-  require "coveralls"
-  Coveralls.wear!
-rescue LoadError
-  warn "warning: coveralls gem not found; skipping Coveralls"
-end
+require 'coveralls'
+Coveralls.wear!
 
-require File.expand_path("../dummy/config/environment.rb", __FILE__)
-require "rails/test_help"
-require File.expand_path("../dummy/test/test_helper.rb", __FILE__)
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+require 'exception_notification'
 
-require "mocha/setup"
+require 'minitest/autorun'
+require 'mocha/minitest'
+require 'active_support/test_case'
+require 'action_mailer'
 
-Rails.backtrace_cleaner.remove_silencers!
 ExceptionNotifier.testing_mode!
+require 'support/exception_notifier_helper'
+
+Time.zone = 'UTC'
+ActionMailer::Base.delivery_method = :test
+ActionMailer::Base.append_view_path "#{File.dirname(__FILE__)}/support/views"