exception_notification 4.2.0 → 4.4.1

data/test/exception_notifier/datadog_notifier_test.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'dogapi/common'
+require 'dogapi/event'
+
+class DatadogNotifierTest < ActiveSupport::TestCase
+  def setup
+    @client = FakeDatadogClient.new
+    @options = {
+      client: @client
+    }
+    @notifier = ExceptionNotifier::DatadogNotifier.new(@options)
+    @exception = FakeException.new
+    @controller = FakeController.new
+    @request = FakeRequest.new
+  end
+
+  test 'should send an event to datadog' do
+    fake_event = Dogapi::Event.any_instance
+    @client.expects(:emit_event).with(fake_event)
+
+    @notifier.stubs(:datadog_event).returns(fake_event)
+    @notifier.call(@exception)
+  end
+
+  test 'should include exception class in event title' do
+    event = @notifier.datadog_event(@exception)
+    assert_includes event.msg_title, 'FakeException'
+  end
+
+  test 'should include prefix in event title and not append previous events' do
+    options = {
+      client: @client,
+      title_prefix: 'prefix'
+    }
+
+    notifier = ExceptionNotifier::DatadogNotifier.new(options)
+    event = notifier.datadog_event(@exception)
+    assert_equal event.msg_title, 'prefix (DatadogNotifierTest::FakeException) "Fake exception message"'
+
+    event2 = notifier.datadog_event(@exception)
+    assert_equal event2.msg_title, 'prefix (DatadogNotifierTest::FakeException) "Fake exception message"'
+  end
+
+  test 'should include exception message in event title' do
+    event = @notifier.datadog_event(@exception)
+    assert_includes event.msg_title, 'Fake exception message'
+  end
+
+  test 'should include controller info in event title if controller information is available' do
+    event = @notifier.datadog_event(@exception,
+                                    env: {
+                                      'action_controller.instance' => @controller,
+                                      'REQUEST_METHOD' => 'GET',
+                                      'rack.input' => ''
+                                    })
+    assert_includes event.msg_title, 'Fake controller'
+    assert_includes event.msg_title, 'Fake action'
+  end
+
+  test 'should include backtrace info in event body' do
+    event = @notifier.datadog_event(@exception)
+    assert_includes event.msg_text, "backtrace line 1\nbacktrace line 2\nbacktrace line 3"
+  end
+
+  test 'should include request info in event body' do
+    ActionDispatch::Request.stubs(:new).returns(@request)
+
+    event = @notifier.datadog_event(@exception,
+                                    env: {
+                                      'action_controller.instance' => @controller,
+                                      'REQUEST_METHOD' => 'GET',
+                                      'rack.input' => ''
+                                    })
+    assert_includes event.msg_text, 'http://localhost:8080'
+    assert_includes event.msg_text, 'GET'
+    assert_includes event.msg_text, '127.0.0.1'
+    assert_includes event.msg_text, '{"param 1"=>"value 1", "param 2"=>"value 2"}'
+  end
+
+  test 'should include tags in event' do
+    options = {
+      client: @client,
+      tags: %w[error production]
+    }
+    notifier = ExceptionNotifier::DatadogNotifier.new(options)
+    event = notifier.datadog_event(@exception)
+    assert_equal event.tags, %w[error production]
+  end
+
+  test 'should include event title in event aggregation key' do
+    event = @notifier.datadog_event(@exception)
+    assert_equal event.aggregation_key, [event.msg_title]
+  end
+
+  class FakeDatadogClient
+    def emit_event(event); end
+  end
+
+  class FakeController
+    def controller_name
+      'Fake controller'
+    end
+
+    def action_name
+      'Fake action'
+    end
+  end
+
+  class FakeException
+    def backtrace
+      [
+        'backtrace line 1',
+        'backtrace line 2',
+        'backtrace line 3',
+        'backtrace line 4',
+        'backtrace line 5'
+      ]
+    end
+
+    def message
+      'Fake exception message'
+    end
+  end
+
+  class FakeRequest
+    def url
+      'http://localhost:8080'
+    end
+
+    def request_method
+      'GET'
+    end
+
+    def remote_ip
+      '127.0.0.1'
+    end
+
+    def filtered_parameters
+      {
+        'param 1' => 'value 1',
+        'param 2' => 'value 2'
+      }
+    end
+
+    def session
+      {
+        'session_id' => '1234'
+      }
+    end
+  end
+end

data/test/exception_notifier/email_notifier_test.rb

@@ -1,181 +1,150 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'action_mailer'
+require 'action_controller'
 
 class EmailNotifierTest < ActiveSupport::TestCase
   setup do
     Time.stubs(:current).returns('Sat, 20 Apr 2013 20:58:55 UTC +00:00')
-    @email_notifier = ExceptionNotifier.registered_exception_notifier(:email)
-    begin
-      1/0
-    rescue => e
-      @exception = e
-      @mail = @email_notifier.create_email(@exception,
-        :data => {:job => 'DivideWorkerJob', :payload => '1/0', :message => 'My Custom Message'})
-    end
-  end
 
-  test "should call pre/post_callback if specified" do
-    assert_equal @email_notifier.options[:pre_callback_called], 1
-    assert_equal @email_notifier.options[:post_callback_called], 1
-  end
+    @exception = ZeroDivisionError.new('divided by 0')
+    @exception.set_backtrace(['test/exception_notifier/email_notifier_test.rb:20'])
+
+    @email_notifier = ExceptionNotifier::EmailNotifier.new(
+      email_prefix: '[Dummy ERROR] ',
+      sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
+      exception_recipients: %w[dummyexceptions@example.com],
+      email_headers: { 'X-Custom-Header' => 'foobar' },
+      sections: %w[new_section request session environment backtrace],
+      background_sections: %w[new_bkg_section backtrace data],
+      pre_callback: proc { |_opts, _notifier, _backtrace, _message, _message_opts| @pre_callback_called = true },
+      post_callback: proc { |_opts, _notifier, _backtrace, _message, _message_opts| @post_callback_called = true },
+      smtp_settings: {
+        user_name: 'Dummy user_name',
+        password: 'Dummy password'
+      }
+    )
 
-  test "should have default sender address overridden" do
-    assert_equal @email_notifier.sender_address, %("Dummy Notifier" <dummynotifier@example.com>)
+    @mail = @email_notifier.call(
+      @exception,
+      data: { job: 'DivideWorkerJob', payload: '1/0', message: 'My Custom Message' }
+    )
   end
 
-  test "should have default exception recipients overridden" do
-    assert_equal @email_notifier.exception_recipients, %w(dummyexceptions@example.com)
+  test 'should call pre/post_callback if specified' do
+    assert @pre_callback_called
+    assert @post_callback_called
   end
 
-  test "should have default email prefix overridden" do
-    assert_equal @email_notifier.email_prefix, "[Dummy ERROR] "
-  end
+  test 'sends mail with correct content' do
+    assert_equal %("Dummy Notifier" <dummynotifier@example.com>), @mail[:from].value
+    assert_equal %w[dummyexceptions@example.com], @mail.to
+    assert_equal '[Dummy ERROR]  (ZeroDivisionError) "divided by 0"', @mail.subject
+    assert_equal 'foobar', @mail['X-Custom-Header'].value
+    assert_equal 'text/plain; charset=UTF-8', @mail.content_type
+    assert_equal [], @mail.attachments
+    assert_equal 'Dummy user_name', @mail.delivery_method.settings[:user_name]
+    assert_equal 'Dummy password', @mail.delivery_method.settings[:password]
 
-  test "should have default email headers overridden" do
-    assert_equal @email_notifier.email_headers, { "X-Custom-Header" => "foobar"}
-  end
+    body = <<-BODY.gsub(/^      /, '')
+      A ZeroDivisionError occurred in background at Sat, 20 Apr 2013 20:58:55 UTC +00:00 :
 
-  test "should have default sections overridden" do
-    for section in %w(new_section request session environment backtrace)
-      assert_includes @email_notifier.sections, section
-    end
-  end
+        divided by 0
+        test/exception_notifier/email_notifier_test.rb:20
 
-  test "should have default background sections" do
-    for section in %w(new_bkg_section backtrace data)
-      assert_includes @email_notifier.background_sections, section
-    end
-  end
+      -------------------------------
+      New bkg section:
+      -------------------------------
 
-  test "should have email format by default" do
-    assert_equal @email_notifier.email_format, :text
-  end
+        * New background section for testing
 
-  test "should have verbose subject by default" do
-    assert @email_notifier.verbose_subject
-  end
-
-  test "should have normalize_subject false by default" do
-    refute @email_notifier.normalize_subject
-  end
-
-  test "should have delivery_method nil by default" do
-    assert_nil @email_notifier.delivery_method
-  end
-
-  test "should have mailer_settings nil by default" do
-    assert_nil @email_notifier.mailer_settings
-  end
+      -------------------------------
+      Backtrace:
+      -------------------------------
 
-  test "should have mailer_parent by default" do
-    assert_equal @email_notifier.mailer_parent, 'ActionMailer::Base'
-  end
+        test/exception_notifier/email_notifier_test.rb:20
 
-  test "should have template_path by default" do
-    assert_equal @email_notifier.template_path, 'exception_notifier'
-  end
+      -------------------------------
+      Data:
+      -------------------------------
 
-  test "should normalize multiple digits into one N" do
-    assert_equal 'N foo N bar N baz N',
-      ExceptionNotifier::EmailNotifier.normalize_digits('1 foo 12 bar 123 baz 1234')
-  end
+        * data: {:job=>"DivideWorkerJob", :payload=>"1/0", :message=>"My Custom Message"}
 
-  test "mail should be plain text and UTF-8 enconded by default" do
-    assert_equal @mail.content_type, "text/plain; charset=UTF-8"
-  end
 
-  test "should have raised an exception" do
-    refute_nil @exception
-  end
+    BODY
 
-  test "should have generated a notification email" do
-    refute_nil @mail
+    assert_equal body, @mail.decode_body
   end
 
-  test "mail should have a from address set" do
-    assert_equal @mail.from, ["dummynotifier@example.com"]
-  end
-
-  test "mail should have a to address set" do
-    assert_equal @mail.to, ["dummyexceptions@example.com"]
-  end
-
-  test "mail should have a descriptive subject" do
-    assert_match /^\[Dummy ERROR\]\s+\(ZeroDivisionError\) "divided by 0"$/, @mail.subject
-  end
-
-  test "mail should say exception was raised in background at show timestamp" do
-    assert_includes @mail.encoded, "A ZeroDivisionError occurred in background at #{Time.current}"
+  test 'should normalize multiple digits into one N' do
+    assert_equal 'N foo N bar N baz N',
+                 ExceptionNotifier::EmailNotifier.normalize_digits('1 foo 12 bar 123 baz 1234')
   end
 
   test "mail should prefix exception class with 'an' instead of 'a' when it starts with a vowel" do
     begin
-      raise ActiveRecord::RecordNotFound
-    rescue => e
+      raise ArgumentError
+    rescue StandardError => e
       @vowel_exception = e
-      @vowel_mail = @email_notifier.create_email(@vowel_exception)
+      @vowel_mail = @email_notifier.call(@vowel_exception)
     end
 
-    assert_includes @vowel_mail.encoded, "An ActiveRecord::RecordNotFound occurred in background at #{Time.current}"
-  end
-
-  test "mail should contain backtrace in body" do
-    assert @mail.encoded.include?("test/exception_notifier/email_notifier_test.rb:9"), "\n#{@mail.inspect}"
-  end
-
-  test "mail should contain data in body" do
-    assert_includes @mail.encoded, '* data:'
-    assert_includes @mail.encoded, ':payload=>"1/0"'
-    assert_includes @mail.encoded, ':job=>"DivideWorkerJob"'
-    assert_includes @mail.encoded, "My Custom Message"
+    assert_includes @vowel_mail.encoded, "An ArgumentError occurred in background at #{Time.current}"
   end
 
-  test "mail should not contain any attachments" do
-    assert_equal @mail.attachments, []
-  end
-
-  test "should not send notification if one of ignored exceptions" do
+  test 'should not send notification if one of ignored exceptions' do
     begin
-      raise ActiveRecord::RecordNotFound
-    rescue => e
+      raise AbstractController::ActionNotFound
+    rescue StandardError => e
       @ignored_exception = e
       unless ExceptionNotifier.ignored_exceptions.include?(@ignored_exception.class.name)
-        ignored_mail = @email_notifier.create_email(@ignored_exception)
+        ignored_mail = @email_notifier.call(@ignored_exception)
       end
     end
 
-    assert_equal @ignored_exception.class.inspect, "ActiveRecord::RecordNotFound"
+    assert_equal @ignored_exception.class.inspect, 'AbstractController::ActionNotFound'
     assert_nil ignored_mail
   end
 
-  test "should encode environment strings" do
+  test 'should encode environment strings' do
     email_notifier = ExceptionNotifier::EmailNotifier.new(
-      :sender_address => "<dummynotifier@example.com>",
-      :exception_recipients => %w{dummyexceptions@example.com},
-      :deliver_with => :deliver_now
+      sender_address: '<dummynotifier@example.com>',
+      exception_recipients: %w[dummyexceptions@example.com]
     )
 
-    mail = email_notifier.create_email(
+    mail = email_notifier.call(
       @exception,
-      :env => {
-        "REQUEST_METHOD" => "GET",
-        "rack.input" => "",
-        "invalid_encoding" => "R\xC3\xA9sum\xC3\xA9".force_encoding(Encoding::ASCII),
-      },
-      :email_format => :text
+      env: {
+        'REQUEST_METHOD' => 'GET',
+        'rack.input' => '',
+        'invalid_encoding' => "R\xC3\xA9sum\xC3\xA9".dup.force_encoding(Encoding::ASCII)
+      }
     )
 
-    assert_match /invalid_encoding\s+: R__sum__/, mail.encoded
+    assert_match(/invalid_encoding\s+: R__sum__/, mail.encoded)
+  end
+
+  test 'should send email using ActionMailer' do
+    ActionMailer::Base.deliveries.clear
+    @email_notifier.call(@exception)
+    assert_equal 1, ActionMailer::Base.deliveries.count
   end
 
-  test "should send email using ActionMailer" do
+  test 'should be able to specify ActionMailer::MessageDelivery method' do
     ActionMailer::Base.deliveries.clear
 
+    deliver_with = if ActionMailer.version < Gem::Version.new('4.2')
+                     :deliver
+                   else
+                     :deliver_now
+                   end
+
     email_notifier = ExceptionNotifier::EmailNotifier.new(
-      :email_prefix => '[Dummy ERROR] ',
-      :sender_address => %{"Dummy Notifier" <dummynotifier@example.com>},
-      :exception_recipients => %w{dummyexceptions@example.com},
-      :delivery_method => :test
+      email_prefix: '[Dummy ERROR] ',
+      sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
+      exception_recipients: %w[dummyexceptions@example.com],
+      deliver_with: deliver_with
     )
 
     email_notifier.call(@exception)
@@ -183,39 +152,226 @@ class EmailNotifierTest < ActiveSupport::TestCase
     assert_equal 1, ActionMailer::Base.deliveries.count
   end
 
-  test "should be able to specify ActionMailer::MessageDelivery method" do
-    ActionMailer::Base.deliveries.clear
+  test 'should lazily evaluate exception_recipients' do
+    exception_recipients = %w[first@example.com second@example.com]
+    email_notifier = ExceptionNotifier::EmailNotifier.new(
+      email_prefix: '[Dummy ERROR] ',
+      sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
+      exception_recipients: -> { [exception_recipients.shift] },
+      delivery_method: :test
+    )
 
-    if ActionMailer.version < Gem::Version.new("4.2")
-      deliver_with = :deliver
-    else
-      deliver_with = :deliver_now
-    end
+    mail = email_notifier.call(@exception)
+    assert_equal %w[first@example.com], mail.to
+    mail = email_notifier.call(@exception)
+    assert_equal %w[second@example.com], mail.to
+  end
 
+  test 'should prepend accumulated_errors_count in email subject if accumulated_errors_count larger than 1' do
     email_notifier = ExceptionNotifier::EmailNotifier.new(
-      :email_prefix => '[Dummy ERROR] ',
-      :sender_address => %{"Dummy Notifier" <dummynotifier@example.com>},
-      :exception_recipients => %w{dummyexceptions@example.com},
-      :deliver_with => deliver_with
+      email_prefix: '[Dummy ERROR] ',
+      sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
+      exception_recipients: %w[dummyexceptions@example.com],
+      delivery_method: :test
     )
 
-    email_notifier.call(@exception)
+    mail = email_notifier.call(@exception, accumulated_errors_count: 3)
+    assert mail.subject.start_with?('[Dummy ERROR] (3 times) (ZeroDivisionError)')
+  end
 
-    assert_equal 1, ActionMailer::Base.deliveries.count
+  test 'should not include exception message in subject when verbose_subject: false' do
+    email_notifier = ExceptionNotifier::EmailNotifier.new(
+      sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
+      exception_recipients: %w[dummyexceptions@example.com],
+      verbose_subject: false
+    )
+
+    mail = email_notifier.call(@exception)
+
+    assert_equal '[ERROR]  (ZeroDivisionError)', mail.subject
   end
 
-  test "should lazily evaluate exception_recipients" do
-    exception_recipients = %w{first@example.com second@example.com}
+  test 'should send html email when selected html format' do
     email_notifier = ExceptionNotifier::EmailNotifier.new(
-      :email_prefix => '[Dummy ERROR] ',
-      :sender_address => %{"Dummy Notifier" <dummynotifier@example.com>},
-      :exception_recipients => -> { [ exception_recipients.shift ] },
-      :delivery_method => :test
+      sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
+      exception_recipients: %w[dummyexceptions@example.com],
+      email_format: :html
     )
 
     mail = email_notifier.call(@exception)
-    assert_equal %w{first@example.com}, mail.to
+
+    assert mail.multipart?
+  end
+end
+
+class EmailNotifierWithEnvTest < ActiveSupport::TestCase
+  class HomeController < ActionController::Metal
+    def index; end
+  end
+
+  setup do
+    Time.stubs(:current).returns('Sat, 20 Apr 2013 20:58:55 UTC +00:00')
+
+    @exception = ZeroDivisionError.new('divided by 0')
+    @exception.set_backtrace(['test/exception_notifier/email_notifier_test.rb:20'])
+
+    @email_notifier = ExceptionNotifier::EmailNotifier.new(
+      email_prefix: '[Dummy ERROR] ',
+      sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
+      exception_recipients: %w[dummyexceptions@example.com],
+      email_headers: { 'X-Custom-Header' => 'foobar' },
+      sections: %w[new_section request session environment backtrace],
+      background_sections: %w[new_bkg_section backtrace data],
+      pre_callback:
+        proc { |_opts, _notifier, _backtrace, _message, message_opts| message_opts[:pre_callback_called] = 1 },
+      post_callback:
+        proc { |_opts, _notifier, _backtrace, _message, message_opts| message_opts[:post_callback_called] = 1 }
+    )
+
+    @controller = HomeController.new
+    @controller.process(:index)
+
+    @test_env = Rack::MockRequest.env_for(
+      '/',
+      'HTTP_HOST' => 'test.address',
+      'REMOTE_ADDR' => '127.0.0.1',
+      'HTTP_USER_AGENT' => 'Rails Testing',
+      'action_dispatch.parameter_filter' => ['secret'],
+      'HTTPS' => 'on',
+      'action_controller.instance' => @controller,
+      params: { id: 'foo', secret: 'secret' }
+    )
+
+    @mail = @email_notifier.call(@exception, env: @test_env, data: { message: 'My Custom Message' })
+  end
+
+  test 'sends mail with correct content' do
+    assert_equal %("Dummy Notifier" <dummynotifier@example.com>), @mail[:from].value
+    assert_equal %w[dummyexceptions@example.com], @mail.to
+    assert_equal '[Dummy ERROR] home index (ZeroDivisionError) "divided by 0"', @mail.subject
+    assert_equal 'foobar', @mail['X-Custom-Header'].value
+    assert_equal 'text/plain; charset=UTF-8', @mail.content_type
+    assert_equal [], @mail.attachments
+
+    body = <<-BODY.gsub(/^      /, '')
+      A ZeroDivisionError occurred in home#index:
+
+        divided by 0
+        test/exception_notifier/email_notifier_test.rb:20
+
+
+      -------------------------------
+      New section:
+      -------------------------------
+
+        * New text section for testing
+
+      -------------------------------
+      Request:
+      -------------------------------
+
+        * URL        : https://test.address/?id=foo&secret=secret
+        * HTTP Method: GET
+        * IP address : 127.0.0.1
+        * Parameters : {\"id\"=>\"foo\", \"secret\"=>\"[FILTERED]\"}
+        * Timestamp  : Sat, 20 Apr 2013 20:58:55 UTC +00:00
+        * Server : #{Socket.gethostname}
+    BODY
+
+    body << "    * Rails root : #{Rails.root}\n" if defined?(Rails) && Rails.respond_to?(:root)
+
+    body << <<-BODY.gsub(/^      /, '')
+        * Process: #{Process.pid}
+
+      -------------------------------
+      Session:
+      -------------------------------
+
+        * session id: [FILTERED]
+        * data: {}
+
+      -------------------------------
+      Environment:
+      -------------------------------
+
+        * CONTENT_LENGTH                            : 0
+          * HTTPS                                     : on
+          * HTTP_HOST                                 : test.address
+          * HTTP_USER_AGENT                           : Rails Testing
+          * PATH_INFO                                 : /
+          * QUERY_STRING                              : id=foo&secret=secret
+          * REMOTE_ADDR                               : 127.0.0.1
+          * REQUEST_METHOD                            : GET
+          * SCRIPT_NAME                               :
+          * SERVER_NAME                               : example.org
+          * SERVER_PORT                               : 80
+          * action_controller.instance                : #{@controller}
+          * action_dispatch.parameter_filter          : [\"secret\"]
+          * action_dispatch.request.content_type      :
+          * action_dispatch.request.parameters        : {"id"=>"foo", "secret"=>"[FILTERED]"}
+          * action_dispatch.request.path_parameters   : {}
+          * action_dispatch.request.query_parameters  : {"id"=>"foo", "secret"=>"[FILTERED]"}
+          * action_dispatch.request.request_parameters: {}
+          * rack.errors                               : #{@test_env['rack.errors']}
+          * rack.input                                : #{@test_env['rack.input']}
+          * rack.multiprocess                         : true
+          * rack.multithread                          : true
+          * rack.request.query_hash                   : {"id"=>"foo", "secret"=>"[FILTERED]"}
+          * rack.request.query_string                 : id=foo&secret=secret
+          * rack.run_once                             : false
+          * rack.session                              : {}
+          * rack.url_scheme                           : http
+          * rack.version                              : #{Rack::VERSION}
+
+      -------------------------------
+      Backtrace:
+      -------------------------------
+
+        test/exception_notifier/email_notifier_test.rb:20
+
+      -------------------------------
+      Data:
+      -------------------------------
+
+        * data: {:message=>\"My Custom Message\"}
+
+
+    BODY
+
+    assert_equal body, @mail.decode_body
+  end
+
+  test 'should not include controller and action names in subject' do
+    email_notifier = ExceptionNotifier::EmailNotifier.new(
+      sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
+      exception_recipients: %w[dummyexceptions@example.com],
+      include_controller_and_action_names_in_subject: false
+    )
+
+    mail = email_notifier.call(@exception, env: @test_env)
+
+    assert_equal '[ERROR]  (ZeroDivisionError) "divided by 0"', mail.subject
+  end
+end
+
+class EmailNotifierWithCustomParentClassTest < ActiveSupport::TestCase
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'infrastructure@example.com'
+  end
+
+  setup do
+    @exception = ZeroDivisionError.new('divided by 0')
+    @exception.set_backtrace(["#{__FILE__}:#{__LINE__}"])
+  end
+
+  test 'uses default from configured parent class' do
+    email_notifier = ExceptionNotifier::EmailNotifier.new(
+      mailer_parent: 'EmailNotifierWithCustomParentClassTest::ApplicationMailer',
+      exception_recipients: %w[dummyexceptions@example.com]
+    )
     mail = email_notifier.call(@exception)
-    assert_equal %w{second@example.com}, mail.to
+
+    assert email_notifier.__send__(:mailer) < ApplicationMailer
+    assert_equal ['infrastructure@example.com'], mail.from
   end
 end