exception_notification 4.6.0 → 5.0.0

data/test/exception_notifier/sns_notifier_test.rb

@@ -1,37 +1,37 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'aws-sdk-sns'
+require "test_helper"
+require "aws-sdk-sns"
 
 class SnsNotifierTest < ActiveSupport::TestCase
   def setup
     @exception = fake_exception
-    @exception.stubs(:class).returns('MyException')
+    @exception.stubs(:class).returns("MyException")
     @exception.stubs(:backtrace).returns(fake_backtrace)
     @exception.stubs(:message).returns("undefined method 'method=' for Empty")
     @options = {
-      access_key_id: 'my-access_key_id',
-      secret_access_key: 'my-secret_access_key',
-      region: 'us-east',
-      topic_arn: 'topicARN',
-      sns_prefix: '[App Exception]'
+      access_key_id: "my-access_key_id",
+      secret_access_key: "my-secret_access_key",
+      region: "us-east",
+      topic_arn: "topicARN",
+      sns_prefix: "[App Exception]"
     }
-    Socket.stubs(:gethostname).returns('example.com')
+    Socket.stubs(:gethostname).returns("example.com")
   end
 
   # initialize
 
-  test 'should initialize aws notifier with received params' do
+  test "should initialize aws notifier with received params" do
     Aws::SNS::Client.expects(:new).with(
-      region: 'us-east',
-      access_key_id: 'my-access_key_id',
-      secret_access_key: 'my-secret_access_key'
+      region: "us-east",
+      access_key_id: "my-access_key_id",
+      secret_access_key: "my-secret_access_key"
     )
 
     ExceptionNotifier::SnsNotifier.new(@options)
   end
 
-  test 'should raise an exception if region is not received' do
+  test "should raise an exception if region is not received" do
     @options[:region] = nil
 
     error = assert_raises ArgumentError do
@@ -40,7 +40,7 @@ class SnsNotifierTest < ActiveSupport::TestCase
     assert_equal "You must provide 'region' option", error.message
   end
 
-  test 'should raise an exception on publish if access_key_id is not received' do
+  test "should raise an exception on publish if access_key_id is not received" do
     @options[:access_key_id] = nil
     error = assert_raises ArgumentError do
       ExceptionNotifier::SnsNotifier.new(@options)
@@ -49,7 +49,7 @@ class SnsNotifierTest < ActiveSupport::TestCase
     assert_equal "You must provide 'access_key_id' option", error.message
   end
 
-  test 'should raise an exception on publish if secret_access_key is not received' do
+  test "should raise an exception on publish if secret_access_key is not received" do
     @options[:secret_access_key] = nil
     error = assert_raises ArgumentError do
       ExceptionNotifier::SnsNotifier.new(@options)
@@ -60,119 +60,122 @@ class SnsNotifierTest < ActiveSupport::TestCase
 
   # call
 
-  test 'should send a sns notification in background' do
+  test "should send a sns notification in background" do
     Aws::SNS::Client.any_instance.expects(:publish).with(
-      topic_arn: 'topicARN',
+      topic_arn: "topicARN",
       message: "3 MyException occured in background\n" \
              "Exception: undefined method 'method=' for Empty\n" \
              "Hostname: example.com\n" \
              "Data: {}\n" \
              "Backtrace:\n#{fake_backtrace.join("\n")}\n",
-      subject: '[App Exception] - 3 MyException occurred'
+      subject: "[App Exception] - 3 MyException occurred"
     )
 
     sns_notifier = ExceptionNotifier::SnsNotifier.new(@options)
     sns_notifier.call(@exception, accumulated_errors_count: 3)
   end
 
-  test 'should send a sns notification with controller#action information' do
-    controller = mock('controller')
-    controller.stubs(:action_name).returns('index')
-    controller.stubs(:controller_name).returns('examples')
+  test "should send a sns notification with controller#action information" do
+    controller = mock("controller")
+    controller.stubs(:action_name).returns("index")
+    controller.stubs(:controller_name).returns("examples")
 
     Aws::SNS::Client.any_instance.expects(:publish).with(
-      topic_arn: 'topicARN',
-      message: 'A MyException occurred while GET </examples> ' \
+      topic_arn: "topicARN",
+      message: "A MyException occurred while GET </examples> " \
              "was processed by examples#index\n" \
              "Exception: undefined method 'method=' for Empty\n" \
              "Hostname: example.com\n" \
              "Data: {}\n" \
              "Backtrace:\n#{fake_backtrace.join("\n")}\n",
-      subject: '[App Exception] - A MyException occurred'
+      subject: "[App Exception] - A MyException occurred"
     )
 
     sns_notifier = ExceptionNotifier::SnsNotifier.new(@options)
     sns_notifier.call(@exception,
-                      env: {
-                        'REQUEST_METHOD' => 'GET',
-                        'REQUEST_URI' => '/examples',
-                        'action_controller.instance' => controller
-                      })
+      env: {
+        "REQUEST_METHOD" => "GET",
+        "REQUEST_URI" => "/examples",
+        "action_controller.instance" => controller
+      })
   end
 
   test 'should put data from env["exception_notifier.exception_data"] into text' do
-    controller = mock('controller')
-    controller.stubs(:action_name).returns('index')
-    controller.stubs(:controller_name).returns('examples')
+    controller = mock("controller")
+    controller.stubs(:action_name).returns("index")
+    controller.stubs(:controller_name).returns("examples")
 
+    # standard:disable Lint/LiteralInInterpolation
     Aws::SNS::Client.any_instance.expects(:publish).with(
-      topic_arn: 'topicARN',
-      message: 'A MyException occurred while GET </examples> ' \
+      topic_arn: "topicARN",
+      message: "A MyException occurred while GET </examples> " \
              "was processed by examples#index\n" \
              "Exception: undefined method 'method=' for Empty\n" \
              "Hostname: example.com\n" \
-             "Data: {:current_user=>12}\n" \
+             "Data: #{{current_user: 12}}\n" \
              "Backtrace:\n#{fake_backtrace.join("\n")}\n",
-      subject: '[App Exception] - A MyException occurred'
+      subject: "[App Exception] - A MyException occurred"
     )
-
+    # standard:enable Lint/LiteralInInterpolation
     sns_notifier = ExceptionNotifier::SnsNotifier.new(@options)
     sns_notifier.call(@exception,
-                      env: {
-                        'REQUEST_METHOD' => 'GET',
-                        'REQUEST_URI' => '/examples',
-                        'action_controller.instance' => controller,
-                        'exception_notifier.exception_data' => { current_user: 12 }
-                      })
+      env: {
+        "REQUEST_METHOD" => "GET",
+        "REQUEST_URI" => "/examples",
+        "action_controller.instance" => controller,
+        "exception_notifier.exception_data" => {current_user: 12}
+      })
   end
-  test 'should put optional data into text' do
-    controller = mock('controller')
-    controller.stubs(:action_name).returns('index')
-    controller.stubs(:controller_name).returns('examples')
 
+  test "should put optional data into text" do
+    controller = mock("controller")
+    controller.stubs(:action_name).returns("index")
+    controller.stubs(:controller_name).returns("examples")
+
+    # standard:disable Lint/LiteralInInterpolation
     Aws::SNS::Client.any_instance.expects(:publish).with(
-      topic_arn: 'topicARN',
-      message: 'A MyException occurred while GET </examples> ' \
+      topic_arn: "topicARN",
+      message: "A MyException occurred while GET </examples> " \
              "was processed by examples#index\n" \
              "Exception: undefined method 'method=' for Empty\n" \
              "Hostname: example.com\n" \
-             "Data: {:current_user=>12}\n" \
+             "Data: #{{current_user: 12}}\n" \
              "Backtrace:\n#{fake_backtrace.join("\n")}\n",
-      subject: '[App Exception] - A MyException occurred'
+      subject: "[App Exception] - A MyException occurred"
     )
-
+    # standard:enable Lint/LiteralInInterpolation
     sns_notifier = ExceptionNotifier::SnsNotifier.new(@options)
     sns_notifier.call(@exception,
-                      env: {
-                        'REQUEST_METHOD' => 'GET',
-                        'REQUEST_URI' => '/examples',
-                        'action_controller.instance' => controller
-                      },
-                      data: {
-                        current_user: 12
-                      })
+      env: {
+        "REQUEST_METHOD" => "GET",
+        "REQUEST_URI" => "/examples",
+        "action_controller.instance" => controller
+      },
+      data: {
+        current_user: 12
+      })
   end
 
   private
 
   def fake_exception
     1 / 0
-  rescue StandardError => e
+  rescue => e
     e
   end
 
   def fake_exception_without_backtrace
-    StandardError.new('my custom error')
+    StandardError.new("my custom error")
   end
 
   def fake_backtrace
     [
-      'backtrace line 1',
-      'backtrace line 2',
-      'backtrace line 3',
-      'backtrace line 4',
-      'backtrace line 5',
-      'backtrace line 6'
+      "backtrace line 1",
+      "backtrace line 2",
+      "backtrace line 3",
+      "backtrace line 4",
+      "backtrace line 5",
+      "backtrace line 6"
     ]
   end
 end

data/test/exception_notifier/teams_notifier_test.rb

@@ -1,87 +1,87 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'httparty'
+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.key? 'title'
-    assert body.key? 'sections'
+    assert body.key? "title"
+    assert body.key? "sections"
 
-    sections = body['sections']
+    sections = body["sections"]
     header = sections[0]
 
     assert_equal 2, sections.size
-    assert_equal 'A *ArgumentError* occurred.', header['activityTitle']
-    assert_equal 'foo', header['activitySubtitle']
+    assert_equal "A *ArgumentError* occurred.", header["activityTitle"]
+    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]
 
-    potential_action = body['potentialAction']
+    potential_action = body["potentialAction"]
     assert_equal 2, potential_action.size
-    assert_equal '🦊 View in GitLab', potential_action[0]['name']
-    assert_equal '🦊 Create Issue in GitLab', potential_action[1]['name']
+    assert_equal "🦊 View in GitLab", potential_action[0]["name"]
+    assert_equal "🦊 Create Issue in GitLab", potential_action[1]["name"]
   end
 
-  test 'should add other HTTParty options to params' do
+  test "should add other HTTParty options to params" do
     options = {
-      webhook_url: 'http://localhost:8000',
-      username: 'Test Bot',
-      avatar: 'http://site.com/icon.png',
+      webhook_url: "http://localhost:8000",
+      username: "Test Bot",
+      avatar: "http://site.com/icon.png",
       basic_auth: {
-        username: 'clara',
-        password: 'password'
+        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.key? :basic_auth
-    assert 'clara', options[:basic_auth][:username]
-    assert 'password', options[:basic_auth][:password]
+    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, {})
 
     message_text = teams_notifier.send(:message_text)
-    header = message_text['sections'][0]
-    assert_equal 'A *ArgumentError* occurred.', header['activityTitle']
+    header = message_text["sections"][0]
+    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)
     message_text = teams_notifier.send(:message_text)
-    header = message_text['sections'][0]
-    assert_equal '5 *ArgumentError* occurred.', header['activityTitle']
+    header = message_text["sections"][0]
+    assert_equal "5 *ArgumentError* occurred.", header["activityTitle"]
   end
 end
 

data/test/exception_notifier/webhook_notifier_test.rb

@@ -1,34 +1,34 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'httparty'
+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].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_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_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
-    url = 'http://localhost:8000'
-    fake_exception.stubs(:backtrace).returns('the backtrace')
+  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)
 
     HTTParty.expects(:send).with(:post, url, fake_params)
@@ -36,9 +36,9 @@ class WebhookNotifierTest < ActiveSupport::TestCase
     webhook.call(fake_exception)
   end
 
-  test 'should call pre/post_callback if specified' do
-    HTTParty.stubs(:send).returns(fake_response)
-    webhook = ExceptionNotifier::WebhookNotifier.new(url: 'http://localhost:8000')
+  test "should call pre/post_callback if specified" do
+    HTTParty.expects(:send).returns(fake_response)
+    webhook = ExceptionNotifier::WebhookNotifier.new(url: "http://localhost:8000")
     webhook.call(fake_exception)
   end
 
@@ -49,21 +49,21 @@ class WebhookNotifierTest < ActiveSupport::TestCase
       status: 200,
       body: {
         exception: {
-          error_class: 'ZeroDivisionError',
-          message: 'divided by 0',
-          backtrace: '/exception_notification/test/webhook_notifier_test.rb:48:in `/'
+          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' }
+          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' }
+          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"}
         }
       }
     }
@@ -75,9 +75,9 @@ class WebhookNotifierTest < ActiveSupport::TestCase
         server: Socket.gethostname,
         process: $PROCESS_ID,
         exception: {
-          error_class: 'ZeroDivisionError',
-          message: 'divided by 0'.inspect,
-          backtrace: 'the backtrace'
+          error_class: "ZeroDivisionError",
+          message: "divided by 0".inspect,
+          backtrace: "the backtrace"
         },
         data: {}
       }
@@ -90,9 +90,9 @@ class WebhookNotifierTest < ActiveSupport::TestCase
 
   def fake_exception
     @fake_exception ||= begin
-                          5 / 0
-                        rescue StandardError => e
-                          e
-                        end
+      5 / 0
+    rescue => e
+      e
+    end
   end
 end