execute_with_rescue_with_airbrake 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a075f476d5e0d9f96a18858757b1f0f967162c8e
+  data.tar.gz: 57fe7504b06259d529e6a56cc4910ac91728ad25
+SHA512:
+  metadata.gz: da8223cb3c1484790c8d9a883faf00f705d572aef2f74c81886ff18e7914d0c0efeb912b2f42a40bda49684be01ea517c08fc7748a480bcf101c308a8648c5d2
+  data.tar.gz: 204f405743ecb2ae9e20d55b3482429383e0d0d443c1281a802325a96016a8c24f430f20bc3392ceb261b52e9ea63538dc0b24d6a0dba647e965c1fc6d8ee848

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.lock

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+cache:
+  - bundler
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.1.1
+gemfile:
+  - gemfiles/rails_3_2.gemfile
+  - gemfiles/rails_4_0.gemfile
+  - gemfiles/rails_4_1.gemfile

data/Appraisals

@@ -0,0 +1,11 @@
+appraise "rails-3-2" do
+  gem "activesupport", "3.2.17"
+end
+
+appraise "rails-4-0" do
+  gem "activesupport", "4.0.4"
+end
+
+appraise "rails-4-1" do
+  gem "activesupport", "4.1.0.rc1"
+end

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+### Changelog
+
+
+- **0.0.1**
+  - Initial Release

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in execute_with_rescue_with_airbrake.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 PikachuEXE
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,101 @@
+# ExecuteWithRescueWithAirbrake
+
+TODO: Write a gem description
+
+The Airbrake adapter plus mixin to be used with `execute_with_rescue`.
+
+## Support
+===========
+Tested against:
+- Active Support of version `3.2`, `4.0` and `4.1` (pre-3.2 got wrong dependency & I don't want to support)
+- MRI `1.9.3`, `2.0.0`, `2.1.0`, `2.1.1`
+
+[![Build Status](http://img.shields.io/travis/PikachuEXE/execute_with_rescue_with_airbrake.svg)](https://travis-ci.org/PikachuEXE/execute_with_rescue_with_airbrake)
+[![Gem Version](http://img.shields.io/gem/v/execute_with_rescue_with_airbrake.svg)](http://badge.fury.io/rb/execute_with_rescue_with_airbrake)
+[![Dependency Status](http://img.shields.io/gemnasium/PikachuEXE/execute_with_rescue_with_airbrake.svg)](https://gemnasium.com/PikachuEXE/execute_with_rescue_with_airbrake)
+[![Coverage Status](http://img.shields.io/coveralls/PikachuEXE/execute_with_rescue_with_airbrake.svg)](https://coveralls.io/r/PikachuEXE/execute_with_rescue_with_airbrake)
+[![Code Climate](http://img.shields.io/codeclimate/github/PikachuEXE/execute_with_rescue_with_airbrake.svg)](https://codeclimate.com/github/PikachuEXE/execute_with_rescue_with_airbrake)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'execute_with_rescue_with_airbrake'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install execute_with_rescue_with_airbrake
+
+## Usage
+
+TODO: Write usage instructions here
+
+Note: You must configurate `airbrake` first or you won't be able to send anything (I have to do the same in `spec_helper`)
+
+### `include ExecuteWithRescue::Mixins::WithAirbrake`
+Once inlcuded, `rescue_from StandardError, with: :notify_by_airbrake_or_raise` will be called.
+
+
+### `#set_default_airbrake_notice_error_class`, `#set_default_airbrake_notice_error_message`, `#add_default_airbrake_notice_parameters`
+**Private** methods to be called within a block in `execute_with_rescue`  
+Every `execute_with_rescue` call will push a new airbrake adapater for the instance (with before hook),  
+so you can have different custom error class, message or/and parameters within the same service/worker class.  
+You should call these methods within the block passed to `execute_with_rescue`, as there is no adapter from the beginning.
+
+Here is an example for getting a document from the network:
+```ruby
+class SomeServiceClass
+
+  BadNetworkConnectionError = Class.new(StandardError)
+
+  include ExecuteWithRescue::Mixins::WithAirbrake
+
+  # then run code with possible errors
+  def perform(url_of_webpage)
+    execute_with_rescue do
+      set_default_airbrake_notice_error_class(BadNetworkConnectionError)
+      set_default_airbrake_notice_error_message("We have a bad network today...")
+      add_default_airbrake_notice_parameters({url_of_webpage: url_of_webpage})
+
+      # Calling `add_default_airbrake_notice_parameters` with duplicated key(s) would raise error
+      # add_default_airbrake_notice_parameters({url_of_webpage: something_else}) => 
+      #   ExecuteWithRescueWithAirbrake::Adapters::AirbrakeAdapter::Errors::ParameterKeyConflict
+
+      doc = Nokogiri::HTML(open(listing_url))
+    end
+  end
+end
+```
+
+### `#notify_by_airbrake_or_raise`
+**Private** method to be called automatically by `rescue_from StandardError` from the mixin.  
+Call this if you have some custom handling for some error classes  
+Override this if you have some additional operation like logging for all kinds of error inherited from `StandardError`  
+Note: It would re-raise the exception if `airbrake` would ignore all notify call in that environment (see `development_environments` in its config).  
+Example:
+```ruby
+class SomeWorker
+  rescue_from ActiveRecord::RecordInvalid,
+              with: :notify_by_airbrake_or_raise_ar_invalid_error
+
+  def notify_by_airbrake_or_raise_ar_invalid_error(ex)
+    add_default_airbrake_notice_parameters({
+      active_record_instance: ex.record.inspect,
+      active_record_instance_errors: ex.record.errors.inspect,
+    })
+    notify_by_airbrake_or_raise(ex)
+  end
+end
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/PikachuEXE/execute_with_rescue_with_airbrake/fork )
+2. Create your feature branch (`git checkout -b feature/my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin feature/my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,16 @@
+require "bundler/gem_tasks"
+require "rubygems"
+require "bundler/setup"
+
+require "rspec/core/rake_task"
+require "appraisal"
+
+RSpec::Core::RakeTask.new(:spec)
+
+if !ENV["APPRAISAL_INITIALIZED"] && !ENV["TRAVIS"]
+  task :default do
+    sh "rake appraisal:install && rake appraisal spec"
+  end
+else
+  task :default => :spec
+end

data/execute_with_rescue_with_airbrake.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'execute_with_rescue_with_airbrake/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "execute_with_rescue_with_airbrake"
+  spec.version       = ExecuteWithRescueWithAirbrake::VERSION
+  spec.authors       = ["PikachuEXE"]
+  spec.email         = ["pikachuexe@gmail.com"]
+  spec.summary       = %q{The Airbrake adapter plus mixin to be used with `execute_with_rescue`}
+  spec.homepage      = "http://github.com/PikachuEXE/execute_with_rescue_with_airbrake"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "execute_with_rescue", "~> 0.0", ">= 0.0.1"
+  spec.add_dependency "airbrake", "~> 3.1.0"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "appraisal", ">= 0.5.2"
+  spec.add_development_dependency "rspec", "~> 2.14.0"
+  spec.add_development_dependency "coveralls", ">= 0.7"
+  spec.add_development_dependency "gem-release", ">= 0.7"
+
+  spec.required_ruby_version = ">= 1.9.3"
+
+  spec.required_rubygems_version = ">= 1.4.0"
+end

data/gemfiles/rails_3_2.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activesupport", "3.2.17"
+
+gemspec :path=>"../"

data/gemfiles/rails_4_0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activesupport", "4.0.4"
+
+gemspec :path=>"../"

data/gemfiles/rails_4_1.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activesupport", "4.1.0.rc1"
+
+gemspec :path=>"../"

data/lib/execute_with_rescue/errors/no_airbrake_adapter.rb

@@ -0,0 +1,13 @@
+module ExecuteWithRescue
+  module Errors
+    class NoAirbrakeAdapter < RuntimeError
+      def self.new(msg = nil)
+        msg ||= <<-ERR_MSG
+          There is no airbrake adapter available.
+          Maybe you forgot to use `execute_with_rescue`?
+        ERR_MSG
+        super(msg)
+      end
+    end
+  end
+end

data/lib/execute_with_rescue/mixins/with_airbrake.rb

@@ -0,0 +1,66 @@
+require 'airbrake'
+require 'active_support/concern'
+require 'active_support/core_ext/module/delegation'
+
+require 'execute_with_rescue'
+require 'execute_with_rescue/errors/no_airbrake_adapter'
+require 'execute_with_rescue_with_airbrake/adapters/airbrake_adapter'
+
+module ExecuteWithRescue
+  module Mixins
+    module WithAirbrake
+      extend ActiveSupport::Concern
+
+      included do
+        include ExecuteWithRescue::Mixins::Core
+
+        add_execute_with_rescue_before_hook do
+          _execute_with_rescue_airbrake_adapters
+          .push(ExecuteWithRescueWithAirbrake::Adapters::AirbrakeAdapter.new)
+        end
+        add_execute_with_rescue_after_hook do
+          _execute_with_rescue_airbrake_adapters.pop
+        end
+
+        rescue_from StandardError,
+                    with: :notify_by_airbrake_or_raise
+
+        delegate :set_default_airbrake_notice_error_class,
+                 :set_default_airbrake_notice_error_message,
+                 :add_default_airbrake_notice_parameters,
+                 to: :_execute_with_rescue_current_airbrake_adapter
+      end
+
+      # Call this if you have some custom handling for some classes
+      # Override this if you have some additional operation like logging
+      # for all kinds of error inherited from `StandardError`
+      #
+      # @example Add default parameters when rescuing AR Invalid Error
+      #   class SomeWorker
+      #     rescue_from ActiveRecord::RecordInvalid,
+      #                 with: :notify_by_airbrake_or_raise_ar_invalid_error
+      #
+      #     def notify_by_airbrake_or_raise_ar_invalid_error(ex)
+      #       add_default_airbrake_notice_parameters({
+      #         active_record_instance: ex.record.inspect,
+      #         active_record_instance_errors: ex.record.errors.inspect,
+      #       })
+      #       notify_by_airbrake_or_raise(ex)
+      #     end
+      #   end
+      def notify_by_airbrake_or_raise(ex)
+        _execute_with_rescue_current_airbrake_adapter
+        .notify_or_raise(ex)
+      end
+
+      # For pushing and popping the adapters
+      def _execute_with_rescue_airbrake_adapters
+        @_execute_with_rescue_airbrake_adapters ||= []
+      end
+      def _execute_with_rescue_current_airbrake_adapter
+        _execute_with_rescue_airbrake_adapters.last ||
+          (raise ExecuteWithRescue::Errors::NoAirbrakeAdapter)
+      end
+    end
+  end
+end

data/lib/execute_with_rescue_with_airbrake.rb

@@ -0,0 +1,7 @@
+require 'execute_with_rescue_with_airbrake/version'
+require 'execute_with_rescue'
+require 'execute_with_rescue/mixins/with_airbrake'
+
+
+module ExecuteWithRescueWithAirbrake
+end

data/lib/execute_with_rescue_with_airbrake/adapters/airbrake_adapter.rb

@@ -0,0 +1,123 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+module ExecuteWithRescueWithAirbrake
+  module Adapters
+    class AirbrakeAdapter
+      module Errors
+        InvalidParameters = Class.new(ArgumentError)
+        ParameterKeyConflict = Class.new(ArgumentError)
+      end
+
+      # This should NOT be used directly, but used with rescue_from
+      # if you need custom options use Airbrake directly
+      #
+      # @param ex [Exception]
+      #   The exception rescued
+      #
+      # @raise [Exception] the original exception
+      #   when Airbrake detects the current environment is not public
+      # @see should_raise?
+      def notify_or_raise(ex)
+        if should_raise?
+          raise ex
+        else
+          notify_or_ignore_with_options(ex)
+        end
+      end
+
+
+      # set the default `error_class` option when notify by Airbrake
+      # It must can be init without argument, this method won't check it
+      # Pass nil to clear it
+      #
+      # @param message [NilClass, Class]
+      #   the error message to be used in Airbrake notice
+      #
+      # @raise [ArgumentError] when class is not nil or symbol
+      def set_default_airbrake_notice_error_class(klass)
+        (klass.nil? || klass.is_a?(Class)) or raise ArgumentError
+
+        @default_airbrake_notice_error_class = klass
+      end
+
+      # set the default `error_message` option when notify by Airbrake
+      # Pass nil to clear it
+      #
+      # @param message [NilClass, String]
+      #   the error message to be used in Airbrake notice
+      #
+      # @raise [ArgumentError] when message is not nil or string
+      def set_default_airbrake_notice_error_message(message)
+        (message.nil? || message.is_a?(String)) or raise ArgumentError
+
+        @default_airbrake_notice_error_message = message
+      end
+
+      # Push new default `parameters` option when notify by Airbrake
+      # Pass nil to clear it
+      #
+      # @param new_params [Hash]
+      #   the additional parameters to be used in Airbrake notice
+      #
+      # @raise [InvalidParameters]
+      #   when new_params is not hash
+      # @raise [ParameterKeyConflict]
+      #   when new_params contains keys conflicting with existing keys
+      def add_default_airbrake_notice_parameters(new_params)
+        new_params.is_a?(Hash) or
+          (raise Errors::InvalidParameters)
+        new_params =
+          new_params.with_indifferent_access
+
+        # find out common element size (which should be 0)
+        common_keys =
+          default_airbrake_notice_parameters.keys &
+          new_params.keys
+        if common_keys.size > 0
+          raise Errors::ParameterKeyConflict,
+                "Conflicting keys: #{common_keys.inspect}"
+        end
+
+        default_airbrake_notice_parameters.merge!(new_params)
+      end
+
+      private
+
+      def notify_or_ignore_with_options(ex)
+        Airbrake.notify_or_ignore(ex, build_notice_options)
+      end
+
+      def build_notice_options
+        result_options_hash = Hash.new
+
+        if @default_airbrake_notice_error_class
+          result_options_hash[:error_class] =
+            @default_airbrake_notice_error_class
+        end
+        if @default_airbrake_notice_error_message
+          result_options_hash[:error_message] =
+            @default_airbrake_notice_error_message
+        end
+        unless default_airbrake_notice_parameters.empty?
+          result_options_hash[:parameters] =
+            default_airbrake_notice_parameters.symbolize_keys
+        end
+
+        result_options_hash
+      end
+
+      def default_airbrake_notice_parameters
+        @default_airbrake_notice_parameters ||= HashWithIndifferentAccess.new
+      end
+
+      # @return [Boolean]
+      #   Whether the adapter should raise the error instead
+      #   (like in development or test)
+      #
+      # @see Airbrake.configuration.development_environments
+      def should_raise?
+        !Airbrake.configuration.public?
+      end
+    end
+  end
+end

data/lib/execute_with_rescue_with_airbrake/version.rb

@@ -0,0 +1,3 @@
+module ExecuteWithRescueWithAirbrake
+  VERSION = "0.0.1"
+end

data/spec/execute_with_rescue/mixins/with_airbrake_spec.rb

@@ -0,0 +1,127 @@
+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
+    let(:adapter_class) do
+      ExecuteWithRescueWithAirbrake::Adapters::AirbrakeAdapter
+    end
+    let!(:adapter_instance) { adapter_class.new }
+    before do
+      # Avoid Error
+      test_class_instance
+      .stub(:_execute_with_rescue_current_airbrake_adapter)
+      .and_return(adapter_instance)
+    end
+  end
+
+  describe 'included modules' do
+    subject { test_class.ancestors }
+
+    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
+      let(:test_class) { TestServiceWithAirbrakeWithoutExecuteWithRescueCall }
+      let(:expected_error_class) { ExecuteWithRescue::Errors::NoAirbrakeAdapter }
+
+      specify do
+        expect{ call_service }
+        .to raise_error(expected_error_class)
+      end
+    end
+    context 'without calling #execute_with_rescue' do
+      let(:test_class) { TestServiceWithAirbrakeWithExecuteWithRescueCall }
+
+      specify do
+        expect{ call_service }
+        .to_not raise_error
+      end
+    end
+    context 'with calling #execute_with_rescue'
+  end
+
+  describe 'delegation' do
+    include_context 'when airbrake adapter assumed exists'
+
+    before { adapter_instance.stub(method_name) }
+
+    let(:send_message) { test_class_instance.send(method_name) }
+
+    shared_examples_for 'delegation' do
+      specify do
+        expect(adapter_instance).to receive(method_name)
+
+        send_message
+      end
+    end
+
+    describe 'for #set_default_airbrake_notice_error_class' do
+      let(:method_name) { :set_default_airbrake_notice_error_class }
+
+      it_behaves_like 'delegation'
+    end
+    describe 'for #set_default_airbrake_notice_error_message' do
+      let(:method_name) { :set_default_airbrake_notice_error_message }
+
+      it_behaves_like 'delegation'
+    end
+    describe 'for #add_default_airbrake_notice_parameters' do
+      let(:method_name) { :add_default_airbrake_notice_parameters }
+
+      it_behaves_like 'delegation'
+    end
+  end
+
+  describe 'execution' do
+    include_context 'when airbrake adapter assumed exists'
+
+    before { Airbrake.configuration.stub(public?: true) }
+
+    describe 'when there is no error raised' do
+      specify do
+        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
+        let(:test_class) { TestServiceWithAirbrakeWithError }
+
+        specify do
+          expect(Airbrake)
+          .to(receive(:notify_or_ignore)
+              .with(kind_of(StandardError), {}))
+
+          call_service
+        end
+      end
+
+      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
+            },
+          }))
+
+          call_service
+        end
+      end
+    end
+  end
+end

data/spec/execute_with_rescue_with_airbrake/adapters/airbrake_adapter_spec.rb

@@ -0,0 +1,211 @@
+require 'spec_helper'
+
+
+describe ExecuteWithRescueWithAirbrake::Adapters::AirbrakeAdapter do
+  let!(:instance) { described_class.new }
+
+  let!(:notice_options) do
+    {parameters: {}}
+  end
+  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
+    before { Airbrake.configuration.stub(public?: false) }
+
+    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
+    before { Airbrake.configuration.stub(public?: true) }
+
+    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
+    before { Airbrake.configuration.stub(public?: true) }
+
+    it 'calls Airbrake.notify_or_ignore' do
+      Airbrake.should_receive(:notify_or_ignore)
+
+      notify_or_raise
+    end
+
+
+    describe '#set_default_airbrake_notice_error_class' do
+      let(:set_error_class) do
+        instance.set_default_airbrake_notice_error_class(
+          default_error_class)
+      end
+      let(:default_error_class) { nil }
+      let(:option_key) { :error_class }
+
+      before do
+        # Return the options only
+        Airbrake.stub(:notify_or_ignore) {|*args| args.last }
+      end
+      let(:options_hash) { notify_or_raise }
+      subject { options_hash }
+
+      context 'when its not called' do
+        its(:keys) { should_not include(option_key) }
+      end
+      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
+        let(:default_error_class) { ArgumentError }
+        before { set_error_class }
+
+        it { should include({option_key => default_error_class}) }
+      end
+    end
+
+    describe '#set_default_airbrake_notice_error_message' do
+      let(:set_error_message) do
+        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
+        Airbrake.stub(:notify_or_ignore) {|*args| args.last }
+      end
+      let(:options_hash) { notify_or_raise }
+      subject { options_hash }
+
+      context 'when its not called' do
+        its(:keys) { should_not include(option_key) }
+      end
+      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' }
+        before { set_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
+      def add_parameters(params = new_parameters)
+        instance.add_default_airbrake_notice_parameters(
+          params)
+      end
+      let(:new_parameters) { Hash.new }
+      let(:option_key) { :parameters }
+
+      before do
+        # Return the options only
+        Airbrake.stub(: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
+        its(:keys) { should_not include(option_key) }
+      end
+      context 'when its called with non hash' do
+        let(:new_parameters) { Array.new }
+        let(:expected_error_class) do
+          described_class::Errors::InvalidParameters
+        end
+
+        specify do
+          expect { add_parameters }
+          .to raise_error(expected_error_class)
+        end
+      end
+      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
+        subject { parameters_hash }
+
+        let(:new_parameters) { {foo: :bar} }
+
+        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
+          before { add_parameters }
+          let(:expected_error_class) do
+            described_class::Errors::ParameterKeyConflict
+          end
+
+          context 'in symbol' do
+            specify do
+              expect { add_parameters }
+              .to raise_error(expected_error_class)
+            end
+          end
+          context 'in string' do
+            specify do
+              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
+        specify do
+          expect(Airbrake)
+          .to(receive(:notify_or_ignore)
+              .with(kind_of(StandardError), {}))
+
+          notify_or_raise
+        end
+      end
+      context 'when all things are set' do
+        let!(:custom_error_class) { Class.new(StandardError) }
+        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,
+          }))
+
+          notify_or_raise
+        end
+      end
+    end
+  end
+end

data/spec/fixtures/test_service_classes.rb

@@ -0,0 +1,51 @@
+
+class TestServiceWithAirbrake
+  include ExecuteWithRescue::Mixins::WithAirbrake
+
+  def call
+    execute_with_rescue do
+      do_something
+    end
+  end
+
+  private
+
+  def do_something
+    # do nothing
+  end
+end
+
+class TestServiceWithAirbrakeWithError < TestServiceWithAirbrake
+  def do_something
+    raise StandardError
+  end
+end
+class TestServiceWithAirbrakeWithErrorAndAirbrakeOption <
+    TestServiceWithAirbrakeWithError
+
+  CustomError = Class.new(StandardError)
+
+  def do_something
+    set_default_airbrake_notice_error_class(CustomError)
+    set_default_airbrake_notice_error_message('hi')
+    add_default_airbrake_notice_parameters({foo: :bar})
+
+    super
+  end
+end
+
+class TestServiceWithAirbrakeWithExecuteWithRescueCall <
+    TestServiceWithAirbrake
+
+  def do_something
+    set_default_airbrake_notice_error_message('test')
+  end
+end
+class TestServiceWithAirbrakeWithoutExecuteWithRescueCall <
+    TestServiceWithAirbrakeWithExecuteWithRescueCall
+
+  def call
+    # without `execute_with_rescue`
+    do_something
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+if ENV["TRAVIS"]
+  require 'coveralls'
+  Coveralls.wear!
+end
+
+require 'execute_with_rescue_with_airbrake'
+require 'airbrake'
+
+require 'fixtures/test_service_classes'
+require 'rspec'
+
+require 'logger'
+
+# Need to configurate it before any `notify_or_ignore`
+Airbrake.configure(true) do |config|
+  config.test_mode = true
+end
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,192 @@
+--- !ruby/object:Gem::Specification
+name: execute_with_rescue_with_airbrake
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- PikachuEXE
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: execute_with_rescue
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: airbrake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: gem-release
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: 
+email:
+- pikachuexe@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Appraisals
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- execute_with_rescue_with_airbrake.gemspec
+- gemfiles/rails_3_2.gemfile
+- gemfiles/rails_3_2.gemfile.lock
+- gemfiles/rails_4_0.gemfile
+- gemfiles/rails_4_0.gemfile.lock
+- gemfiles/rails_4_1.gemfile
+- gemfiles/rails_4_1.gemfile.lock
+- lib/execute_with_rescue/errors/no_airbrake_adapter.rb
+- lib/execute_with_rescue/mixins/with_airbrake.rb
+- lib/execute_with_rescue_with_airbrake.rb
+- lib/execute_with_rescue_with_airbrake/adapters/airbrake_adapter.rb
+- lib/execute_with_rescue_with_airbrake/version.rb
+- spec/execute_with_rescue/mixins/with_airbrake_spec.rb
+- spec/execute_with_rescue_with_airbrake/adapters/airbrake_adapter_spec.rb
+- spec/fixtures/test_service_classes.rb
+- spec/spec_helper.rb
+homepage: http://github.com/PikachuEXE/execute_with_rescue_with_airbrake
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.4.0
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: The Airbrake adapter plus mixin to be used with `execute_with_rescue`
+test_files:
+- spec/execute_with_rescue/mixins/with_airbrake_spec.rb
+- spec/execute_with_rescue_with_airbrake/adapters/airbrake_adapter_spec.rb
+- spec/fixtures/test_service_classes.rb
+- spec/spec_helper.rb
+has_rdoc: