exception_notification 4.6.0 → 5.0.0

data/test/exception_notifier/email_notifier_test.rb

@@ -1,53 +1,54 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'action_mailer'
-require 'action_controller'
+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')
+    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'])
+    @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] ',
+      email_prefix: "[Dummy ERROR] ",
       sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
       exception_recipients: %w[dummyexceptions@example.com],
-      email_headers: { 'X-Custom-Header' => 'foobar' },
+      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'
+        user_name: "Dummy user_name",
+        password: "Dummy password"
       }
     )
 
     @mail = @email_notifier.call(
       @exception,
-      data: { job: 'DivideWorkerJob', payload: '1/0', message: 'My Custom Message' }
+      data: {job: "DivideWorkerJob", payload: "1/0", message: "My Custom Message"}
     )
   end
 
-  test 'should call pre/post_callback if specified' do
+  test "should call pre/post_callback if specified" do
     assert @pre_callback_called
     assert @post_callback_called
   end
 
-  test 'sends mail with correct content' do
+  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 "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]
+    assert_equal "Dummy user_name", @mail.delivery_method.settings[:user_name]
+    assert_equal "Dummy password", @mail.delivery_method.settings[:password]
 
-    body = <<-BODY.gsub(/^      /, '')
+    # standard:disable Lint/LiteralInInterpolation
+    body = <<~BODY
       A ZeroDivisionError occurred in background at Sat, 20 Apr 2013 20:58:55 UTC +00:00 :
 
         divided by 0
@@ -69,23 +70,24 @@ class EmailNotifierTest < ActiveSupport::TestCase
       Data:
       -------------------------------
 
-        * data: {:job=>"DivideWorkerJob", :payload=>"1/0", :message=>"My Custom Message"}
+        * data: #{{job: "DivideWorkerJob", payload: "1/0", message: "My Custom Message"}}
 
 
     BODY
+    # standard:enable Lint/LiteralInInterpolation
 
     assert_equal body, @mail.decode_body
   end
 
-  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')
+  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 ArgumentError
-    rescue StandardError => e
+    rescue => e
       @vowel_exception = e
       @vowel_mail = @email_notifier.call(@vowel_exception)
     end
@@ -93,55 +95,55 @@ class EmailNotifierTest < ActiveSupport::TestCase
     assert_includes @vowel_mail.encoded, "An ArgumentError occurred in background at #{Time.current}"
   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 AbstractController::ActionNotFound
-    rescue StandardError => e
+    rescue => e
       @ignored_exception = e
       unless ExceptionNotifier.ignored_exceptions.include?(@ignored_exception.class.name)
         ignored_mail = @email_notifier.call(@ignored_exception)
       end
     end
 
-    assert_equal @ignored_exception.class.inspect, 'AbstractController::ActionNotFound'
+    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>',
+      sender_address: "<dummynotifier@example.com>",
       exception_recipients: %w[dummyexceptions@example.com]
     )
 
     mail = email_notifier.call(
       @exception,
       env: {
-        'REQUEST_METHOD' => 'GET',
-        'rack.input' => '',
-        'invalid_encoding' => "R\xC3\xA9sum\xC3\xA9".dup.force_encoding(Encoding::ASCII)
+        "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)
   end
 
-  test 'should send email using ActionMailer' do
+  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 be able to specify ActionMailer::MessageDelivery method' 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
+    deliver_with = if ActionMailer.version < Gem::Version.new("4.2")
+      :deliver
+    else
+      :deliver_now
+    end
 
     email_notifier = ExceptionNotifier::EmailNotifier.new(
-      email_prefix: '[Dummy ERROR] ',
+      email_prefix: "[Dummy ERROR] ",
       sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
       exception_recipients: %w[dummyexceptions@example.com],
       deliver_with: deliver_with
@@ -152,10 +154,10 @@ class EmailNotifierTest < ActiveSupport::TestCase
     assert_equal 1, ActionMailer::Base.deliveries.count
   end
 
-  test 'should lazily evaluate exception_recipients' do
+  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] ',
+      email_prefix: "[Dummy ERROR] ",
       sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
       exception_recipients: -> { [exception_recipients.shift] },
       delivery_method: :test
@@ -167,19 +169,19 @@ class EmailNotifierTest < ActiveSupport::TestCase
     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
+  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] ',
+      email_prefix: "[Dummy ERROR] ",
       sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
       exception_recipients: %w[dummyexceptions@example.com],
       delivery_method: :test
     )
 
     mail = email_notifier.call(@exception, accumulated_errors_count: 3)
-    assert mail.subject.start_with?('[Dummy ERROR] (3 times) (ZeroDivisionError)')
+    assert mail.subject.start_with?("[Dummy ERROR] (3 times) (ZeroDivisionError)")
   end
 
-  test 'should not include exception message in subject when verbose_subject: false' do
+  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],
@@ -188,10 +190,10 @@ class EmailNotifierTest < ActiveSupport::TestCase
 
     mail = email_notifier.call(@exception)
 
-    assert_equal '[ERROR]  (ZeroDivisionError)', mail.subject
+    assert_equal "[ERROR]  (ZeroDivisionError)", mail.subject
   end
 
-  test 'should send html email when selected html format' do
+  test "should send html email when selected html format" do
     email_notifier = ExceptionNotifier::EmailNotifier.new(
       sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
       exception_recipients: %w[dummyexceptions@example.com],
@@ -206,20 +208,21 @@ end
 
 class EmailNotifierWithEnvTest < ActiveSupport::TestCase
   class HomeController < ActionController::Metal
-    def index; end
+    def index
+    end
   end
 
   setup do
-    Time.stubs(:current).returns('Sat, 20 Apr 2013 20:58:55 UTC +00:00')
+    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'])
+    @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] ',
+      email_prefix: "[Dummy ERROR] ",
       sender_address: %("Dummy Notifier" <dummynotifier@example.com>),
       exception_recipients: %w[dummyexceptions@example.com],
-      email_headers: { 'X-Custom-Header' => 'foobar' },
+      email_headers: {"X-Custom-Header" => "foobar"},
       sections: %w[new_section request session environment backtrace],
       background_sections: %w[new_bkg_section backtrace data],
       pre_callback:
@@ -232,29 +235,32 @@ class EmailNotifierWithEnvTest < ActiveSupport::TestCase
     @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,
-      'rack.session.options' => {},
-      params: { id: 'foo', secret: 'secret' }
+      "/",
+      "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,
+      "rack.session.options" => {},
+      :params => {id: "foo", secret: "secret"}
     )
 
-    @mail = @email_notifier.call(@exception, env: @test_env, data: { message: 'My Custom Message' })
+    @mail = @email_notifier.call(@exception, env: @test_env, data: {message: "My Custom Message"})
   end
 
-  test 'sends mail with correct content' do
+  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 "foobar", @mail["X-Custom-Header"].value
+    assert_equal "text/plain; charset=UTF-8", @mail.content_type
     assert_equal [], @mail.attachments
 
-    body = <<-BODY.gsub(/^      /, '')
+    body_fragments = []
+
+    # standard:disable Lint/LiteralInInterpolation
+    body_fragments << <<~BODY
       A ZeroDivisionError occurred in home#index:
 
         divided by 0
@@ -274,14 +280,14 @@ class EmailNotifierWithEnvTest < ActiveSupport::TestCase
         * URL        : https://test.address/?id=foo&secret=secret
         * HTTP Method: GET
         * IP address : 127.0.0.1
-        * Parameters : {\"id\"=>\"foo\", \"secret\"=>\"[FILTERED]\"}
+        * 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_fragments << "    * Rails root : #{Rails.root}\n" if defined?(Rails) && Rails.respond_to?(:root)
 
-    body << <<-BODY.gsub(/^      /, '')
+    body_fragments << <<~BODY
         * Process: #{Process.pid}
 
       -------------------------------
@@ -295,30 +301,13 @@ class EmailNotifierWithEnvTest < ActiveSupport::TestCase
       Environment:
       -------------------------------
 
-        * 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
-          * SERVER_PROTOCOL                           : HTTP/1.1
-          * action_controller.instance                : #{@controller}
-          * action_dispatch.parameter_filter          : [\"secret\"]
-          * 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.request.form_hash                    : {}
-          * rack.request.form_input                   :
-          * rack.session                              : #{@test_env['rack.session']}
-          * rack.session.options                      : #{@test_env['rack.session.options']}
-          * rack.url_scheme                           : http
+    BODY
+
+    body_fragments << "* action_controller.instance"
+    body_fragments << "* rack.errors"
+    body_fragments << "[FILTERED]"
 
+    body_fragments << <<~BODY
       -------------------------------
       Backtrace:
       -------------------------------
@@ -329,15 +318,17 @@ class EmailNotifierWithEnvTest < ActiveSupport::TestCase
       Data:
       -------------------------------
 
-        * data: {:message=>\"My Custom Message\"}
+        * data: #{{message: "My Custom Message"}}
 
 
     BODY
-
-    assert_equal body, @mail.decode_body
+    # standard:enable Lint/LiteralInInterpolation
+    body_fragments.each do |fragment|
+      assert_includes @mail.decode_body, fragment
+    end
   end
 
-  test 'should not include controller and action names in subject' do
+  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],
@@ -346,6 +337,6 @@ class EmailNotifierWithEnvTest < ActiveSupport::TestCase
 
     mail = email_notifier.call(@exception, env: @test_env)
 
-    assert_equal '[ERROR]  (ZeroDivisionError) "divided by 0"', mail.subject
+    assert_equal "[ERROR]  (ZeroDivisionError) \"divided by 0\"", mail.subject
   end
 end

data/test/exception_notifier/google_chat_notifier_test.rb

@@ -1,130 +1,130 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'rack'
-require 'httparty'
-require 'timecop'
-require 'json'
+require "test_helper"
+require "rack"
+require "httparty"
+require "timecop"
+require "json"
 
 class GoogleChatNotifierTest < ActiveSupport::TestCase
-  URL = 'http://localhost:8000'
+  URL = "http://localhost:8000"
 
   def setup
-    Timecop.freeze('2018-12-09 12:07:16 UTC')
+    Timecop.freeze("2018-12-09 12:07:16 UTC")
   end
 
   def teardown
     Timecop.return
   end
 
-  test 'should send notification if properly configured' do
-    HTTParty.expects(:post).with(URL, post_opts("#{header}\n#{body}"))
-    notifier.call ArgumentError.new('foo')
+  test "should send notification if properly configured" do
+    HTTParty.expects(:post).with(URL, **post_opts("#{header}\n#{body}"))
+    notifier.call ArgumentError.new("foo")
   end
 
-  test 'shoud use errors count if accumulated_errors_count is provided' do
+  test "shoud use errors count if accumulated_errors_count is provided" do
     text = [
-      '',
+      "",
       "Application: *#{app_name}*",
-      '5 *ArgumentError* occurred.',
-      '',
+      "5 *ArgumentError* occurred.",
+      "",
       body
     ].join("\n")
 
-    HTTParty.expects(:post).with(URL, post_opts(text))
+    HTTParty.expects(:post).with(URL, **post_opts(text))
 
-    notifier.call(ArgumentError.new('foo'), accumulated_errors_count: 5)
+    notifier.call(ArgumentError.new("foo"), accumulated_errors_count: 5)
   end
 
-  test 'Message request should be formatted as hash' do
+  test "Message request should be formatted as hash" do
     text = [
       header,
       body,
-      '',
-      '*Request:*',
-      '```',
-      '* url : http://test.address/?id=foo',
-      '* http_method : GET',
-      '* ip_address : 127.0.0.1',
-      '* parameters : {"id"=>"foo"}',
-      '* timestamp : 2018-12-09 12:07:16 UTC',
-      '```'
+      "",
+      "*Request:*",
+      "```",
+      "* url : http://test.address/?id=foo",
+      "* http_method : GET",
+      "* ip_address : 127.0.0.1",
+      "* parameters : #{{"id" => "foo"}}", # standard:disable Lint/LiteralInInterpolation:
+      "* timestamp : 2018-12-09 12:07:16 UTC",
+      "```"
     ].join("\n")
 
-    HTTParty.expects(:post).with(URL, post_opts(text))
+    HTTParty.expects(:post).with(URL, **post_opts(text))
 
-    notifier.call(ArgumentError.new('foo'), env: test_env)
+    notifier.call(ArgumentError.new("foo"), env: test_env)
   end
 
-  test 'backtrace with less than 3 lines should be displayed fully' do
+  test "backtrace with less than 3 lines should be displayed fully" do
     text = [
       header,
       body,
-      '',
+      "",
       backtrace
     ].join("\n")
 
-    HTTParty.expects(:post).with(URL, post_opts(text))
+    HTTParty.expects(:post).with(URL, **post_opts(text))
 
-    exception = ArgumentError.new('foo')
+    exception = ArgumentError.new("foo")
     exception.set_backtrace([
-                              "app/controllers/my_controller.rb:53:in `my_controller_params'",
-                              "app/controllers/my_controller.rb:34:in `update'"
-                            ])
+      "app/controllers/my_controller.rb:53:in `my_controller_params'",
+      "app/controllers/my_controller.rb:34:in `update'"
+    ])
 
     notifier.call(exception)
   end
 
-  test 'backtrace with more than 3 lines should display only top 3 lines' do
+  test "backtrace with more than 3 lines should display only top 3 lines" do
     text = [
       header,
       body,
-      '',
-      '*Backtrace:*',
-      '```',
+      "",
+      "*Backtrace:*",
+      "```",
       "* app/controllers/my_controller.rb:99:in `specific_function'",
       "* app/controllers/my_controller.rb:70:in `specific_param'",
       "* app/controllers/my_controller.rb:53:in `my_controller_params'",
-      '```'
+      "```"
     ].join("\n")
 
-    HTTParty.expects(:post).with(URL, post_opts(text))
+    HTTParty.expects(:post).with(URL, **post_opts(text))
 
-    exception = ArgumentError.new('foo')
+    exception = ArgumentError.new("foo")
     exception.set_backtrace([
-                              "app/controllers/my_controller.rb:99:in `specific_function'",
-                              "app/controllers/my_controller.rb:70:in `specific_param'",
-                              "app/controllers/my_controller.rb:53:in `my_controller_params'",
-                              "app/controllers/my_controller.rb:34:in `update'"
-                            ])
+      "app/controllers/my_controller.rb:99:in `specific_function'",
+      "app/controllers/my_controller.rb:70:in `specific_param'",
+      "app/controllers/my_controller.rb:53:in `my_controller_params'",
+      "app/controllers/my_controller.rb:34:in `update'"
+    ])
 
     notifier.call(exception)
   end
 
-  test 'Get text with backtrace and request info' do
+  test "Get text with backtrace and request info" do
     text = [
       header,
       body,
-      '',
-      '*Request:*',
-      '```',
-      '* url : http://test.address/?id=foo',
-      '* http_method : GET',
-      '* ip_address : 127.0.0.1',
-      '* parameters : {"id"=>"foo"}',
-      '* timestamp : 2018-12-09 12:07:16 UTC',
-      '```',
-      '',
+      "",
+      "*Request:*",
+      "```",
+      "* url : http://test.address/?id=foo",
+      "* http_method : GET",
+      "* ip_address : 127.0.0.1",
+      "* parameters : #{{"id" => "foo"}}", # standard:disable Lint/LiteralInInterpolation:
+      "* timestamp : 2018-12-09 12:07:16 UTC",
+      "```",
+      "",
       backtrace
     ].join("\n")
 
-    HTTParty.expects(:post).with(URL, post_opts(text))
+    HTTParty.expects(:post).with(URL, **post_opts(text))
 
-    exception = ArgumentError.new('foo')
+    exception = ArgumentError.new("foo")
     exception.set_backtrace([
-                              "app/controllers/my_controller.rb:53:in `my_controller_params'",
-                              "app/controllers/my_controller.rb:34:in `update'"
-                            ])
+      "app/controllers/my_controller.rb:53:in `my_controller_params'",
+      "app/controllers/my_controller.rb:34:in `update'"
+    ])
 
     notifier.call(exception, env: test_env)
   end
@@ -137,27 +137,27 @@ class GoogleChatNotifierTest < ActiveSupport::TestCase
 
   def post_opts(text)
     {
-      body: { text: text }.to_json,
-      headers: { 'Content-Type' => 'application/json' }
+      body: {text: text}.to_json,
+      headers: {"Content-Type" => "application/json"}
     }
   end
 
   def test_env
     Rack::MockRequest.env_for(
-      '/',
-      'HTTP_HOST' => 'test.address',
-      'REMOTE_ADDR' => '127.0.0.1',
-      'HTTP_USER_AGENT' => 'Rails Testing',
-      params: { id: 'foo' }
+      "/",
+      "HTTP_HOST" => "test.address",
+      "REMOTE_ADDR" => "127.0.0.1",
+      "HTTP_USER_AGENT" => "Rails Testing",
+      :params => {id: "foo"}
     )
   end
 
   def header
     [
-      '',
+      "",
       "Application: *#{app_name}*",
-      'An *ArgumentError* occurred.',
-      ''
+      "An *ArgumentError* occurred.",
+      ""
     ].join("\n")
   end
 
@@ -170,16 +170,16 @@ class GoogleChatNotifierTest < ActiveSupport::TestCase
   end
 
   def app_name
-    'dummy' if defined?(::Rails) && ::Rails.respond_to?(:application)
+    "dummy" if defined?(::Rails) && ::Rails.respond_to?(:application)
   end
 
   def backtrace
     [
-      '*Backtrace:*',
-      '```',
+      "*Backtrace:*",
+      "```",
       "* app/controllers/my_controller.rb:53:in `my_controller_params'",
       "* app/controllers/my_controller.rb:34:in `update'",
-      '```'
+      "```"
     ]
   end
 end