execute_with_rescue_with_airbrake 0.0.2 → 0.0.3

data/lib/execute_with_rescue_with_airbrake/version.rb

@@ -1,3 +1,3 @@
 module ExecuteWithRescueWithAirbrake
-  VERSION = "0.0.2"
+  VERSION = "0.0.3".freeze
 end

data/spec/execute_with_rescue/mixins/with_airbrake_spec.rb

@@ -1,54 +1,53 @@
-require 'spec_helper'
-
+require "spec_helper"
 
 describe ExecuteWithRescue::Mixins::WithAirbrake do
   let(:test_class) { TestServiceWithAirbrake }
   let(:test_class_instance) { test_class.new }
   let(:call_service) { test_class_instance.call }
 
-  shared_context 'when airbrake adapter assumed exists' do
+  shared_context "when airbrake adapter assumed exists" do
     let(:adapter_class) do
       ExecuteWithRescueWithAirbrake::Adapters::AirbrakeAdapter
     end
     let!(:adapter_instance) { adapter_class.new }
     before do
       # Avoid Error
-      allow(test_class_instance)
-      .to receive(:_execute_with_rescue_current_airbrake_adapter)
-          .and_return(adapter_instance)
+      allow(test_class_instance).
+        to receive(:_execute_with_rescue_current_airbrake_adapter).
+        and_return(adapter_instance)
     end
   end
 
-  describe 'included modules' do
+  describe "included modules" do
     subject { test_class.ancestors }
 
-    it {should include ExecuteWithRescue::Mixins::Core}
-    it {should include ExecuteWithRescue::Mixins::WithAirbrake}
+    it { should include ExecuteWithRescue::Mixins::Core }
+    it { should include ExecuteWithRescue::Mixins::WithAirbrake }
   end
 
-  describe 'call delegated methods' do
-    context 'without calling #execute_with_rescue' do
+  describe "call delegated methods" do
+    context "without calling #execute_with_rescue" do
       let(:test_class) { TestServiceWithAirbrakeWithoutExecuteWithRescueCall }
       let(:expected_error_class) { ExecuteWithRescue::Errors::NoAirbrakeAdapter }
 
       specify do
-        expect{ call_service }
-        .to raise_error(expected_error_class)
+        expect { call_service }.
+          to raise_error(expected_error_class)
       end
     end
-    context 'without calling #execute_with_rescue' do
+    context "without calling #execute_with_rescue" do
       let(:test_class) { TestServiceWithAirbrakeWithExecuteWithRescueCall }
 
       specify do
-        expect{ call_service }
-        .to_not raise_error
+        expect { call_service }.
+          to_not raise_error
       end
     end
-    context 'with calling #execute_with_rescue'
+    context "with calling #execute_with_rescue"
   end
 
-  describe 'delegation' do
-    include_context 'when airbrake adapter assumed exists'
+  describe "delegation" do
+    include_context "when airbrake adapter assumed exists"
 
     before do
       allow(adapter_instance).to receive(method_name)
@@ -56,7 +55,7 @@ describe ExecuteWithRescue::Mixins::WithAirbrake do
 
     let(:send_message) { test_class_instance.send(method_name) }
 
-    shared_examples_for 'delegation' do
+    shared_examples_for "delegation" do
       specify do
         expect(adapter_instance).to receive(method_name)
 
@@ -64,77 +63,80 @@ describe ExecuteWithRescue::Mixins::WithAirbrake do
       end
     end
 
-    describe 'for #set_default_airbrake_notice_error_class' do
+    describe "for #set_default_airbrake_notice_error_class" do
       let(:method_name) { :set_default_airbrake_notice_error_class }
 
-      it_behaves_like 'delegation'
+      it_behaves_like "delegation"
     end
-    describe 'for #set_default_airbrake_notice_error_message' do
+    describe "for #set_default_airbrake_notice_error_message" do
       let(:method_name) { :set_default_airbrake_notice_error_message }
 
-      it_behaves_like 'delegation'
+      it_behaves_like "delegation"
     end
-    describe 'for #add_default_airbrake_notice_parameters' do
+    describe "for #add_default_airbrake_notice_parameters" do
       let(:method_name) { :add_default_airbrake_notice_parameters }
 
-      it_behaves_like 'delegation'
+      it_behaves_like "delegation"
     end
   end
 
-  describe 'execution' do
-    include_context 'when airbrake adapter assumed exists'
+  describe "execution" do
+    include_context "when airbrake adapter assumed exists"
 
     before { allow(Airbrake.configuration).to receive(:public?) { true } }
 
-    describe 'when there is no error raised' do
+    describe "when there is no error raised" do
       specify do
-        expect(Airbrake)
-        .to_not receive(:notify_or_ignore)
+        expect(Airbrake).
+          to_not receive(:notify_or_ignore)
 
         call_service
       end
     end
-    describe 'when there is error raised' do
-      context 'and it is a standard error' do
+    describe "when there is error raised" do
+      context "and it is a standard error" do
         let(:test_class) { TestServiceWithAirbrakeWithError }
 
         specify do
-          expect(Airbrake)
-          .to(receive(:notify_or_ignore)
-              .with(kind_of(StandardError), {}))
+          expect(Airbrake).
+            to receive(:notify_or_ignore).
+            with(kind_of(StandardError), {})
 
           call_service
         end
       end
 
-      describe 'setting custom airbrake options' do
+      describe "setting custom airbrake options" do
         let(:test_class) { TestServiceWithAirbrakeWithErrorAndAirbrakeOption }
 
         specify do
-          expect(Airbrake)
-          .to(receive(:notify_or_ignore)
-              .with(kind_of(StandardError), {
-            error_class: test_class::CustomError,
-            error_message: 'hi',
-            parameters: {
-              foo: :bar
-            },
-          }))
+          expect(Airbrake).
+            to receive(:notify_or_ignore).
+            with(
+              kind_of(StandardError),
+              error_class:   test_class::CustomError,
+              error_message: "hi",
+              parameters:    {
+                foo: :bar
+              },
+            )
 
           call_service
         end
       end
 
-      describe 'setting custom airbrake options with an error that requires argument on initialize' do
+      describe "setting custom airbrake options with an error "\
+        "that requires argument on initialize" do
         let(:test_class) { TestServiceWithAirbrakeWithCustomErrorAndMessage }
 
         specify do
-          expect(Airbrake)
-          .to(receive(:notify_or_ignore)
-              .with(kind_of(StandardError), {
-            error_class: test_class::CustomErrorWithMessage,
-            error_message: "#{:foo.class} has error",
-          }))
+          expect(Airbrake).
+            to receive(:notify_or_ignore).
+            with(
+              kind_of(StandardError),
+              error_class:   test_class::CustomErrorWithMessage,
+              error_message: "#{:foo.class} has error",
+            )
 
           call_service
         end

data/spec/execute_with_rescue_with_airbrake/adapters/airbrake_adapter_spec.rb

@@ -1,5 +1,4 @@
-require 'spec_helper'
-
+require "spec_helper"
 
 describe ExecuteWithRescueWithAirbrake::Adapters::AirbrakeAdapter do
   let!(:instance) { described_class.new }
@@ -7,41 +6,39 @@ describe ExecuteWithRescueWithAirbrake::Adapters::AirbrakeAdapter do
   let!(:notice_options) do
     {parameters: {}}
   end
-  let!(:exception_rescued) { StandardError.new('hi I am test error') }
+  let!(:exception_rescued) { StandardError.new("hi I am test error") }
 
   let(:notify_or_raise) { instance.notify_or_raise(exception_rescued) }
 
-  #before {  }
-
-  context 'when exception should not be notified according to Airbrake' do
+  context "when exception should not be notified according to Airbrake" do
     before { allow(Airbrake.configuration).to receive(:public?) { false } }
 
-    it 're-raise the rescue error' do
-      expect { notify_or_raise }.to raise_error(exception_rescued.class,
-                                                exception_rescued.message)
+    it "re-raise the rescue error" do
+      expect { notify_or_raise }.
+        to raise_error(
+          exception_rescued.class,
+          exception_rescued.message,
+        )
     end
   end
-  context 'when exception should be notified according to Airbrake' do
+  context "when exception should be notified according to Airbrake" do
     before { allow(Airbrake.configuration).to receive(:public?) { true } }
 
-    it 'does not re-raise the rescued error' do
+    it "does not re-raise the rescued error" do
       expect { notify_or_raise }.to_not raise_error
     end
   end
 
-  context 'assuming Airbrake says it error should be notified' do
+  context "assuming Airbrake says it error should be notified" do
     before { allow(Airbrake.configuration).to receive(:public?) { true } }
 
-    it 'calls Airbrake.notify_or_ignore' do
+    it "calls Airbrake.notify_or_ignore" do
       expect(Airbrake).to receive(:notify_or_ignore)
 
       notify_or_raise
-
-      # expect(Airbrake).to have_received(:notify_or_ignore)
     end
 
-
-    describe '#set_default_airbrake_notice_error_class' do
+    describe "#set_default_airbrake_notice_error_class" do
       let(:set_error_class) do
         instance.set_default_airbrake_notice_error_class(
           default_error_class)
@@ -51,62 +48,62 @@ describe ExecuteWithRescueWithAirbrake::Adapters::AirbrakeAdapter do
 
       before do
         # Return the options only
-        allow(Airbrake).to receive(:notify_or_ignore) {|*args| args.last }
+        allow(Airbrake).to receive(:notify_or_ignore) { |*args| args.last }
       end
       let(:options_hash) { notify_or_raise }
       subject { options_hash }
 
-      context 'when its not called' do
+      context "when its not called" do
         its(:keys) { should_not include(option_key) }
       end
-      context 'when its called with nil' do
+      context "when its called with nil" do
         let(:default_error_class) { nil }
         before { set_error_class }
 
         its(:keys) { should_not include(option_key) }
       end
-      context 'when its called with custom error' do
+      context "when its called with custom error" do
         let(:default_error_class) { ArgumentError }
         before { set_error_class }
 
-        it { should include({option_key => default_error_class}) }
+        it { should include(option_key => default_error_class) }
       end
     end
 
-    describe '#set_default_airbrake_notice_error_message' do
+    describe "#set_default_airbrake_notice_error_message" do
       let(:set_error_message) do
-        instance.set_default_airbrake_notice_error_message(
-          default_error_message)
+        instance.
+          set_default_airbrake_notice_error_message(default_error_message)
       end
       let(:default_error_message) { nil }
       let(:option_key) { :error_message }
 
       before do
         # Return the options only
-        allow(Airbrake).to receive(:notify_or_ignore) {|*args| args.last }
+        allow(Airbrake).to receive(:notify_or_ignore) { |*args| args.last }
       end
       let(:options_hash) { notify_or_raise }
       subject { options_hash }
 
-      context 'when its not called' do
+      context "when its not called" do
         its(:keys) { should_not include(option_key) }
       end
-      context 'when its called with nil' do
+      context "when its called with nil" do
         let(:default_error_message) { nil }
         before { set_error_message }
 
         its(:keys) { should_not include(option_key) }
       end
-      context 'when its called with custom error' do
-        let(:default_error_message) { 'hello' }
+      context "when its called with custom error" do
+        let(:default_error_message) { "hello" }
         before { set_error_message }
 
-        it { should include({option_key => default_error_message}) }
+        it { should include(option_key => default_error_message) }
       end
     end
 
-    describe '#add_default_airbrake_notice_parameters' do
-      # Must defined as method or it won't run twice
+    describe "#add_default_airbrake_notice_parameters" do
+      # Must defined as method or it won"t run twice
       def add_parameters(params = new_parameters)
         instance.add_default_airbrake_notice_parameters(
           params)
@@ -116,94 +113,95 @@ describe ExecuteWithRescueWithAirbrake::Adapters::AirbrakeAdapter do
 
       before do
         # Return the options only
-        allow(Airbrake).to receive(:notify_or_ignore) {|*args| args.last }
+        allow(Airbrake).
+          to receive(:notify_or_ignore) { |*args| args.last }
       end
       let(:options_hash) { notify_or_raise }
       let(:parameters_hash) { options_hash[option_key] }
 
       subject { options_hash }
 
-      context 'when its not called' do
+      context "when its not called" do
         its(:keys) { should_not include(option_key) }
       end
-      context 'when its called with non hash' do
-        let(:new_parameters) { Array.new }
+      context "when its called with non hash" do
+        let(:new_parameters) { [] }
         let(:expected_error_class) do
           described_class::Errors::InvalidParameters
         end
 
         specify do
-          expect { add_parameters }
-          .to raise_error(expected_error_class)
+          expect { add_parameters }.
+            to raise_error(expected_error_class)
         end
       end
-      context 'when its called with empty hash' do
+      context "when its called with empty hash" do
         let(:new_parameters) { Hash.new }
         before { add_parameters }
 
         its(:keys) { should_not include(option_key) }
       end
 
-      context 'when its called with non-empty hash' do
+      context "when its called with non-empty hash" do
         subject { parameters_hash }
 
         let(:new_parameters) { {foo: :bar} }
 
-        context 'and there is no conflicting key' do
+        context "and there is no conflicting key" do
           before { add_parameters }
 
           it { should include(new_parameters) }
         end
 
-        context 'and there is a conflicting key' do
+        context "and there is a conflicting key" do
           before { add_parameters }
           let(:expected_error_class) do
             described_class::Errors::ParameterKeyConflict
           end
 
-          context 'in symbol' do
+          context "in symbol" do
             specify do
-              expect { add_parameters }
-              .to raise_error(expected_error_class)
+              expect { add_parameters }.
+                to raise_error(expected_error_class)
             end
           end
-          context 'in string' do
+          context "in string" do
             specify do
-              expect { add_parameters(new_parameters.stringify_keys) }
-              .to raise_error(expected_error_class)
+              expect { add_parameters(new_parameters.stringify_keys) }.
+                to raise_error(expected_error_class)
             end
           end
         end
       end
     end
 
-
-    describe 'options passed' do
-      context 'when nothing is set' do
+    describe "options passed" do
+      context "when nothing is set" do
         specify do
-          expect(Airbrake)
-          .to(receive(:notify_or_ignore)
-              .with(kind_of(StandardError), {}))
+          expect(Airbrake).
+            to receive(:notify_or_ignore).
+            with(kind_of(StandardError), {})
 
           notify_or_raise
         end
       end
-      context 'when all things are set' do
+      context "when all things are set" do
         let!(:custom_error_class) { Class.new(StandardError) }
-        let!(:custom_error_message) { 'hi' }
+        let!(:custom_error_message) { "hi" }
         let!(:custom_parameters) { {foo: :bar}.stringify_keys }
         before { instance.set_default_airbrake_notice_error_class(custom_error_class) }
         before { instance.set_default_airbrake_notice_error_message(custom_error_message) }
         before { instance.add_default_airbrake_notice_parameters(custom_parameters) }
 
         specify do
-          expect(Airbrake)
-          .to(receive(:notify_or_ignore)
-              .with(kind_of(StandardError), {
-            error_class: custom_error_class,
-            error_message: custom_error_message,
-            parameters: custom_parameters.symbolize_keys,
-          }))
+          expect(Airbrake).
+            to receive(:notify_or_ignore).
+            with(
+              kind_of(StandardError),
+              error_class:   custom_error_class,
+              error_message: custom_error_message,
+              parameters:    custom_parameters.symbolize_keys,
+            )
 
           notify_or_raise
         end