errorapp_notifier 0.1.0

data/spec/errorapp_notifier/controller_failure_data_spec.rb

@@ -0,0 +1,277 @@
+require 'spec_helper'
+
+describe ErrorappNotifier::ControllerFailureData do
+
+  class ErrorappNotifier::OmgError < StandardError
+    def backtrace
+      ['omg-backtrace']
+    end
+  end
+
+  class BrokenJSON
+    def to_json
+      omg
+    end
+  end
+
+  it "parses session data" do
+    request = ActionDispatch::TestRequest.new
+    brokenJson = BrokenJSON.new
+    session = {:foo  => brokenJson}
+    request.stub(:session).and_return(session)
+    data = ErrorappNotifier::ControllerFailureData.new(ErrorappNotifier::OmgError.new, nil, request)
+
+    JSON.parse(data.to_json)['request']['session']['data'].should == {'foo' => brokenJson.to_s}
+  end
+
+  it "raises useful error when to_json isn't available on to_hash" do
+    data = ErrorappNotifier::FailureData.new(ErrorappNotifier::OmgError.new)
+    hash_without_json = {}
+    hash_without_json.stub(:to_json).and_raise(NoMethodError)
+    data.stub(:to_hash).and_return(hash_without_json)
+    expect { data.to_json }.to raise_exception(/to_json/)
+  end
+
+  describe 'when no request/controller/params' do
+    before do
+      ENV['LOGNAME'] = 'bob'
+      ENV['SOMETHING_SECRET'] = 'secretPasswords'
+      ENV['DATABASE_URL'] = 'something'
+      ENV['SOMETHING_INTERESTING'] = 'instagram'
+      ENV['HTTP_SOMETHING'] = 'should be stripped'
+      ENV['FILTERED_BY_OLD_FILTER_CONFIG'] = 'should_be_filtered'
+      ErrorappNotifier::ENVIRONMENT_WHITELIST << /_INTERESTING/
+        ErrorappNotifier::ENVIRONMENT_WHITELIST << 'FILTERED_BY_OLD_FILTER_CONFIG'
+      ErrorappNotifier::ENVIRONMENT_FILTER << 'FILTERED_BY_OLD_FILTER_CONFIG'
+      RAILS_ENV = 'test' unless defined?(RAILS_ENV)
+      @occured_at = Time.mktime(1970, 1, 1)
+      Time.stub(:now).and_return(Time.mktime(1970, 1, 1))
+      error = ErrorappNotifier::OmgError.new('some message')
+      @data = ErrorappNotifier::ControllerFailureData.new(error)
+      @hash = @data.to_hash
+    end
+
+    it "capture exception details" do
+      error_hash = @hash[:exception]
+      error_hash[:exception_class].should == 'ErrorappNotifier::OmgError'
+      error_hash[:message].should == 'some message'
+      error_hash[:backtrace].should == ['omg-backtrace']
+      DateTime.parse(error_hash[:occurred_at]).should == @occured_at
+      client_hash = @hash[:client]
+      client_hash[:name].should == ErrorappNotifier::CLIENT_NAME
+      client_hash[:version].should == ErrorappNotifier::VERSION
+      client_hash[:protocol_version].should == ErrorappNotifier::PROTOCOL_VERSION
+    end
+
+
+    it "has sensible initial ENVIRONMENT_WHITELIST" do
+      %w(HOME PATH PWD RUBYOPT GEM_HOME RACK_ENV RAILS_ENV BUNDLE_GEMFILE BUNDLE_BIN_PATH).each do |expected_to_be_whitelisted|
+        ErrorappNotifier::ENVIRONMENT_WHITELIST.should include(expected_to_be_whitelisted)
+      end
+    end
+
+    it "uses a whitelist for ENV variables aswell as existing filter" do
+      env = @hash[:application_environment][:env]
+      env['SOMETHING_SECRET'].should be_nil
+      env['DATABASE_URL'].should be_nil
+      env['HTTP_SOMETHING'].should be_nil
+      env['FILTERED_BY_OLD_FILTER_CONFIG'].should be_nil
+      env['SOMETHING_INTERESTING'].should == 'instagram'
+    end
+
+    it "generates parseable json" do
+      require 'json'
+      JSON.parse(@data.to_json)['exception']['exception_class'].should == 'ErrorappNotifier::OmgError'
+    end
+
+    it "capture application_environment" do
+      application_env_hash = @hash[:application_environment]
+      application_env_hash[:environment].should == 'test'
+      application_env_hash[:env].should_not be_nil
+      application_env_hash[:host].should == `hostname`.strip
+      application_env_hash[:run_as_user].should == 'bob'
+      application_env_hash[:application_root_directory].should == Dir.pwd
+      application_env_hash[:language].should == 'ruby'
+      application_env_hash[:language_version].should == "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} #{RUBY_RELEASE_DATE} #{RUBY_PLATFORM}"
+      application_env_hash[:libraries_loaded]['rspec'].should == '2.14.0'
+    end
+  end
+
+  describe 'with request/controller/params' do
+
+    class ErrorappNotifier::SomeController
+    end
+
+    before :each do
+      @controller = ErrorappNotifier::SomeController.new
+      @request = ActionDispatch::TestRequest.new
+      @request.stub(:parameters).and_return({'var1' => 'abc', 'action' => 'some_action', 'filter_me' => 'private'})
+      @request.stub(:url).and_return('http://youtube.com/watch?v=oHg5SJYRHA0')
+      @request.stub(:request_method).and_return(:get)
+      @request.stub(:remote_ip).and_return('1.2.3.4')
+      @request.stub(:env).and_return({'SOME_VAR' => 'abc', 'HTTP_CONTENT_TYPE' => 'text/html'})
+      @request.env["action_dispatch.parameter_filter"] = [:filter_me]
+      @error = ErrorappNotifier::OmgError.new('some message')
+      data = ErrorappNotifier::ControllerFailureData.new(@error, @controller, @request)
+      @hash = data.to_hash
+    end
+
+    it "captures request" do
+      request_hash = @hash[:request]
+      request_hash[:url].should == 'http://youtube.com/watch?v=oHg5SJYRHA0'
+      request_hash[:controller].should == 'ErrorappNotifier::SomeController'
+      request_hash[:action].should == 'some_action'
+      request_hash[:parameters].should == {'var1' => 'abc', 'action' => 'some_action', 'filter_me' => '[FILTERED]'}
+      request_hash[:request_method].should == 'get'
+      request_hash[:remote_ip].should == '1.2.3.4'
+      request_hash[:headers].should == {'Content-Type' => 'text/html'}
+    end
+
+
+    it "filter params specified in env['action_dispatch.parameter_filter']" do
+      @request.stub(:env).and_return({'SOME_VAR' => 'abc', 'HTTP_CONTENT_TYPE' => 'text/html', 'action_dispatch.parameter_filter' => [:var1]})
+      @request.stub(:parameters).and_return({'var1' => 'abc'})
+      data = ErrorappNotifier::ControllerFailureData.new(@error, @controller, @request)
+      data.to_hash[:request][:parameters].should == {'var1' => '[FILTERED]'}
+    end
+
+    it "filter nested params specified in env['action_dispatch.parameter_filter']" do
+      @request.stub(:env).and_return({'SOME_VAR' => 'abc', 'HTTP_CONTENT_TYPE' => 'text/html', 'action_dispatch.parameter_filter' => [:var1]})
+      @request.stub(:parameters).and_return({'var1' => {'var2' => 'abc','var3' => "abc"}})
+      data = ErrorappNotifier::ControllerFailureData.new(@error, @controller, @request)
+      data.to_hash[:request][:parameters].should == {'var1' => '[FILTERED]'}
+    end
+
+    it "formats the occurred_at as iso8601" do
+      @request.stub(:env).and_return({'SOME_VAR' => 'abc', 'HTTP_CONTENT_TYPE' => 'text/html', 'action_dispatch.parameter_filter' => [:var1]})
+      @request.stub(:parameters).and_return({'var1' => 'abc'})
+      data = ErrorappNotifier::ControllerFailureData.new(@error, @controller, @request)
+      data.to_hash[:exception][:occurred_at].should match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.{1,6}$/)
+    end
+
+    it "filter session cookies from headers" do
+      @request.stub(:env).and_return({'SOME_VAR' => 'abc', 'HTTP_COOKIE' => '_something_else=faafsafafasfa; _myapp-lick-nation_session=BAh7DDoMbnVtYmVyc1sJaQZpB2kIaQk6FnNvbWVfY3Jhenlfb2JqZWN0bzobU3Bpa2VDb250cm9sbGVyOjpDcmF6eQY6CUBiYXJABzoTc29tZXRoaW5nX2Vsc2UiCGNjYzoKYXBwbGUiDUJyYWVidXJuOgloYXNoewdpBmkHaQhpCToPc2Vzc2lvbl9pZCIlMmJjZTM4MjVjMThkNzYxOWEyZDA4NTJhNWY1NGQzMmU6C3RvbWF0byIJQmVlZg%3D%3D--66fb4606851f06bf409b8bc4ba7aea47f0259bf7'})
+      @hash = ErrorappNotifier::ControllerFailureData.new(ErrorappNotifier::OmgError.new('some message'), @controller, @request).to_hash
+      @hash[:request][:headers].should == {'Cookie' => '_something_else=faafsafafasfa; _myapp-lick-nation_session=[FILTERED]'}
+    end
+
+    it "creates a uniq_key from backtrace" do
+      exception = Exception.new
+      exception.stub(:backtrace).and_return(['123'])
+      data = ErrorappNotifier::ControllerFailureData.new(exception)
+      data.uniq_key.should == Digest::MD5.hexdigest('123')
+    end
+
+    it "creates a nil uniq_key if nil backtrace" do
+      exception = Exception.new
+      exception.stub(:backtrace).and_return(nil)
+      data = ErrorappNotifier::ControllerFailureData.new(exception)
+      data.uniq_key.should == nil
+    end
+
+    it "creates a uniq_key from backtrace" do
+      exception = Exception.new
+      exception.stub(:backtrace).and_return([])
+      data = ErrorappNotifier::ControllerFailureData.new(exception)
+      data.uniq_key.should == nil
+    end
+  end
+end
+
+describe ErrorappNotifier::ControllerDataExtractor do
+  before do
+    @request = double(
+      :protocol    => "http://",
+      :host        => "errorapp",
+      :request_uri => "/projects",
+      :params =>
+      {
+        "action" => "index",
+        "controller" => "projects",
+        "foo"        => "bar"
+      },
+        :request_method => "GET",
+        :ip             => "1.2.3.4",
+        :env            => "fuzzy"
+    )
+    @controller = "Controller"
+  end
+
+  subject { ErrorappNotifier::ControllerDataExtractor.new(@controller, @request) }
+
+  it "should extract the controller class" do
+    subject.controller.should == "String"
+  end
+
+  it "should extract the URL" do
+    subject.url.should == "http://errorapp/projects"
+  end
+
+  it "should extract action" do
+    subject.action.should == "index"
+  end
+
+  it "should extract parameters" do
+    subject.parameters.should == {
+      "action" => "index",
+      "controller" => "projects",
+      "foo" => "bar"
+    }
+  end
+
+  it "should extract request method" do
+    subject.request_method.should == "GET"
+  end
+
+  it "should extract remote ip" do
+    subject.remote_ip.should == "1.2.3.4"
+  end
+
+  it "should extract env" do
+    subject.env.should == "fuzzy"
+  end
+
+  it "should make request available" do
+    subject.request.should == @request
+  end
+
+  context "with params available in request" do
+    before do
+      @request = double(
+        :url    => "http://errorapp/projects",
+        :parameters =>
+        {
+          "action" => "index",
+          "controller" => "projects",
+          "foo"        => "bar"
+        },
+          :request_method => "GET",
+          :remote_ip      => "1.2.3.4",
+          :env            => "fuzzy"
+      )
+      @controller = "Controller"
+    end
+
+    subject { ErrorappNotifier::ControllerDataExtractor.new(@controller, @request) }
+
+    it "should extract the URL" do
+      subject.url.should == "http://errorapp/projects"
+    end
+
+    it "should extract action" do
+      subject.action.should == "index"
+    end
+
+    it "should extract parameters" do
+      subject.parameters.should == {
+        "action" => "index",
+        "controller" => "projects",
+        "foo" => "bar"
+      }
+    end
+
+    it "should extract remote ip" do
+      subject.remote_ip.should == "1.2.3.4"
+    end
+  end
+end

data/spec/errorapp_notifier/failure_data_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'digest/md5'
+require 'time'
+
+describe ErrorappNotifier::FailureData do
+  describe "#to_hash" do
+    before do
+      @exception = ErrorappNotifier::FailureData.new(build_exception).to_hash
+    end
+
+    it "should get exception data" do
+      expect(@exception[:exception][:exception_class]).to eq("TestException")
+      expect(@exception[:exception][:message]).to match(/Something is not good/)
+      expect(@exception[:exception][:backtrace]).not_to be_empty
+      expect(@exception[:exception][:occurred_at]).to eq(Time.now.utc.iso8601)
+    end
+
+    it "should get application data" do
+      expect(@exception[:application_environment][:environment]).to eq('test')
+
+      expect(@exception[:application_environment][:env].class).to eq(Hash)
+      expect(@exception[:application_environment][:env].keys).to include('PATH','HOME', 'GEM_HOME', 'BUNDLE_BIN_PATH')
+    end
+  end
+end
+
+def build_exception
+  backtrace = ["errorapp/spec/helper.rb:8:in `deafult_message'",
+               "errorapp/spec/spec_helper.rb:4:in `require'",
+                 "lib/active_support/dependencies.rb:247:in `require'"]
+  TestException.new(:backtrace => backtrace)
+end

data/spec/errorapp_notifier/notifier_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe ErrorappNotifier::Notifier do
+  before :each do
+    ErrorappNotifier.configure do|config|
+      config.api_key = 'api-key'
+    end
+  end
+
+  it 'should call notify_error to send exception data' do
+    ErrorappNotifier::Notifier.stub(:notify_error)
+    exception_data = double(:uniq_key => 1, :to_json => 'something')
+
+    ErrorappNotifier::Notifier.notify_error(exception_data)
+
+    expect(ErrorappNotifier::Notifier).to have_received(:notify_error)
+  end
+
+  describe 'notify_error' do
+    it 'should get 200 when sending exception' do
+      exception_data = double(:uniq_key => 1, :to_json => 'something')
+
+      stub_request(
+        :post,
+        "http://errorapp.com/api/projects/api-key/fails?hash=#{exception_data.uniq_key}&protocol_version=#{ErrorappNotifier::PROTOCOL_VERSION}"
+      ).with(:body => exception_data.to_json).to_return(:status => 200, :body => "", :headers => {})
+
+      ErrorappNotifier::Notifier.notify_error(exception_data)
+    end
+  end
+end

data/spec/errorapp_notifier/notify_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe ErrorappNotifier::Notify do
+  describe "when ErrorappNotifier reporting is on" do
+
+    before do
+      @config = ErrorappNotifier::configuration
+      @config.stub(:should_send_to_api?).and_return(true)
+      @config.ignore_user_agents = []
+    end
+
+    describe "#notify" do
+      it "should create FailureData object and send json to the api" do
+        exception = double("exception")
+        name = double("name")
+        args = [exception, name]
+        data = double("data")
+
+        ErrorappNotifier::FailureData.should_receive(:new).with(*args).and_return(data)
+        ErrorappNotifier::Notifier.should_receive(:notify_error).with(data)
+        ErrorappNotifier::Notify.notify(*args)
+      end
+    end
+
+    describe "#notify_with_controller" do
+      it "should create ControllerFailureData object and send json to the api" do
+        exception = double('exception')
+        controller = double('controller')
+        request = double('request')
+        args = [exception, controller, request]
+        data = double("data")
+
+        ErrorappNotifier::ControllerFailureData.should_receive(:new).with(*args).and_return(data)
+        ErrorappNotifier::Notifier.should_receive(:notify_error).with(data)
+        ErrorappNotifier::Notify.notify_with_controller(*args)
+      end
+    end
+
+    describe "#notify_with_rack" do
+      it "should create RackFailureData object and send json to the api" do
+        exception = double("exception")
+        environment = double("environment")
+        request = double("request")
+        args = [exception, environment, request]
+        data = double("data")
+
+        ErrorappNotifier::RackFailureData.should_receive(:new).with(*args).and_return(data)
+        ErrorappNotifier::Notifier.should_receive(:notify_error).with(data)
+        ErrorappNotifier::Notify.notify_with_rack(*args)
+      end
+    end
+
+    describe "#ignore?" do
+
+      before do
+        @exception = double('exception')
+        @controller = double('controller')
+        @request = double('request')
+      end
+
+      it "should check for ignored classes and agents" do
+        ErrorappNotifier::Notify.should_receive(:ignore_class?).with(@exception)
+        ErrorappNotifier::Notify.should_receive(:ignore_user_agent?).with(@request)
+        ErrorappNotifier::ControllerFailureData.should_receive(:new).
+          with(@exception,@controller,@request).
+          and_return(data = double('data'))
+        ErrorappNotifier::Notifier.should_receive(:notify_error).with(data)
+
+        ErrorappNotifier::Notify.notify_with_controller(@exception,
+                                                         @controller,
+                                                         @request)
+      end
+
+      it "should ignore exceptions by class name" do
+        request = double("request")
+        exception = double("exception")
+        exception.stub(:class).and_return("ignore_me")
+        exception.should_receive(:class)
+
+        @config.ignore_exceptions = ["ignore_me",/funky/]
+        ErrorappNotifier::Notify.ignore_class?(exception).should be_true
+        funky_exception = double("exception")
+        funky_exception.stub(:class).and_return("really_funky_exception")
+        funky_exception.should_receive(:class)
+
+        ErrorappNotifier::Notify.ignore_class?(funky_exception).should be_true
+      end
+
+      it "should ignore exceptions by user agent" do
+        request = double("request")
+        request.stub(:user_agent).and_return("botmeister")
+        request.should_receive(:user_agent)
+
+        @config.ignore_user_agents = [/bot/]
+        ErrorappNotifier::Notify.ignore_user_agent?(request).should be_true
+      end
+
+    end
+  end
+
+  describe "when ErrorappNotifier reporting is off" do
+
+    before do
+      ErrorappNotifier::Config.stub(:should_send_to_api?).and_return(false)
+    end
+
+    describe "#notify, #notify_with_controller and #notify_with_rack" do
+
+      it "should reraise the exception and not report it" do
+        exception = double('exception')
+        controller = double('controller')
+        request = double('request')
+
+        ErrorappNotifier::ControllerFailureData.should_not_receive(:new)
+        ErrorappNotifier::Notifier.should_not_receive(:notify_error)
+
+        ["rails", "rack", ""].each do |notify|
+          method_name = "notify"
+          method_name << "_with_#{notify}" unless notify.empty?
+          expect do
+            ErrorappNotifier::Notify.send(method_name, exception, controller, request)
+          end.to raise_exception
+        end
+      end
+    end
+  end
+end
+

data/spec/errorapp_notifier/rack_failure_data_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'rack'
+require 'time'
+
+describe ErrorappNotifier::RackFailureData do
+
+  class ErrorappNotifier::OmgError < StandardError
+    def backtrace
+      ['omg-backtrace']
+    end
+  end
+
+  before :each do
+    app = lambda { |env| [200, {'Content-Type'=>'text/plain'}, 'Hello World']}
+
+    @env = {
+      "HTTP_HOST" =>"localhost:4242",
+      "HTTP_ACCEPT" =>"*/*",
+      "SERVER_NAME" =>"localhost",
+      "REQUEST_PATH" =>"/",
+      "rack.url_scheme" =>"http",
+      "HTTP_USER_AGENT" =>"curl/7.19.6 (i386-apple-darwin9.8.0) libcurl/7.19.6 zlib/1.2.3",
+      "REMOTE_HOST" =>"testing.com",
+      "rack.errors" => StringIO.new,
+      "SERVER_PROTOCOL" =>"HTTP/1.1",
+      "rack.version" =>[1, 1],
+      "rack.run_once" =>false,
+      "SERVER_SOFTWARE" =>"WEBrick/1.3.1 (Ruby/1.8.7/2009-06-12)",
+      "REMOTE_ADDR" =>"127.0.0.1",
+      "PATH_INFO" => "/",
+      "SCRIPT_NAME" =>"",
+      "HTTP_VERSION" =>"HTTP/1.1",
+      "rack.multithread" =>true,
+      "rack.multiprocess" =>false,
+      "REQUEST_URI" =>"http://localhost:4242/",
+      "SERVER_PORT" =>"4242",
+      "REQUEST_METHOD" =>"GET",
+      "rack.input" => StringIO.new,
+      "QUERY_STRING" =>"cockle=shell&bay=cool",
+      "GATEWAY_INTERFACE" =>"CGI/1.1"
+    }
+
+    error = ErrorappNotifier::OmgError.new('some message')
+    request = Rack::Request.new(@env)
+    @data = ErrorappNotifier::RackFailureData.new(error, @env, request)
+  end
+
+  it "capture exception details" do
+    error_hash = @data.to_hash[:exception]
+    error_hash[:exception_class].should == 'ErrorappNotifier::OmgError'
+    error_hash[:message].should == 'some message'
+    error_hash[:backtrace].should == ['omg-backtrace']
+    DateTime.parse(error_hash[:occurred_at]).should == DateTime.parse(Time.now.to_s)
+  end
+
+  it "should capture request details" do
+    request_hash = @data.to_hash[:request]
+    request_hash[:url].should == 'http://localhost:4242/?cockle=shell&bay=cool'
+    request_hash[:parameters].should == {"cockle"=>"shell", "bay"=>"cool"}
+    request_hash[:request_method].should == 'GET'
+    request_hash[:remote_ip].should == '127.0.0.1'
+    request_hash[:headers].should == {"Host"=>"localhost:4242", "Accept"=>"*/*", "User-Agent"=>"curl/7.19.6 (i386-apple-darwin9.8.0) libcurl/7.19.6 zlib/1.2.3", "Version"=>"HTTP/1.1"}
+    request_hash[:session].should == {'data' => {}, 'session_id' => ''}
+  end
+
+  it "should capture client detais" do
+    client_hash = @data.to_hash[:client]
+    client_hash[:name].should == 'errorapp_notifier-gem'
+    client_hash[:version].should == ErrorappNotifier::VERSION
+    client_hash[:protocol_version].should == 1
+  end
+
+  it "should captire application environment" do
+    env_hash = @data.to_hash[:application_environment]
+    env_hash[:env].should_not be_empty
+    env_hash[:libraries_loaded].should_not be_empty
+    env_hash[:language].should == 'ruby'
+
+    env_hash[:language_version].should_not be_empty
+    env_hash[:environment].should == 'test'
+    env_hash[:application_root_directory].should_not be_empty
+    env_hash[:run_as_user].should_not be_empty
+    env_hash[:host].should_not be_empty
+  end
+
+end
+

data/spec/errorapp_notifier/sanitizer_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe ErrorappNotifier::Sanitizer do
+  describe '.sanitize_hash' do
+    it "filter out objects that aren't jsonable" do
+      class Crazy
+        def initialize
+          @bar = self
+        end
+      end
+      crazy = Crazy.new
+      input = {'crazy' => crazy, :simple => '123',
+               :some_hash => {'1' => '2'}, :array => ['1', '2']}
+      ErrorappNotifier::Sanitizer.sanitize_hash(input).should == {'crazy' => crazy.to_s,
+                                                                  :simple => '123', :some_hash => {'1' => '2'}, :array => ['1', '2']}
+    end
+
+    it "to_strings regex because JSON.parse(/aa/.to_json) doesn't work" do
+      input = {'crazy' => /abc.*/}
+      ErrorappNotifier::Sanitizer.sanitize_hash(input).should == {'crazy' => /abc.*/.to_s}
+    end
+
+    it "handles session objects with various interfaces" do
+      class SessionWithInstanceVariables
+        def initialize
+          @data = {'a' => '1', 'b' => /hello there Im a regex/i}
+          @session_id = '123'
+        end
+      end
+
+      request = ActionDispatch::TestRequest.new
+      session = SessionWithInstanceVariables.new
+      request.stub(:session).and_return(session)
+      request.stub(:session_options).and_return({})
+      ErrorappNotifier::Sanitizer.sanitize_session(request).should == {'session_id' => '123', 'data' => {'a' => '1', 'b' => "(?i-mx:hello there Im a regex)"}}
+      session = double('session', :session_id => '123', :instance_variable_get => {'a' => '1', 'b' => /another(.+) regex/mx})
+      request.stub(:session).and_return(session)
+      ErrorappNotifier::Sanitizer.sanitize_session(request).should == {'session_id' => '123', 'data' => {'a' => '1', 'b' => "(?mx-i:another(.+) regex)"}}
+      session = double('session', :session_id => nil, :to_hash => {:session_id => '123', 'a' => '1'})
+      request.stub(:session).and_return(session)
+      ErrorappNotifier::Sanitizer.sanitize_session(request).should == {'session_id' => '123', 'data' => {'a' => '1'}}
+      request.stub(:session_options).and_return({:id => 'xyz'})
+      ErrorappNotifier::Sanitizer.sanitize_session(request).should == {'session_id' => 'xyz', 'data' => {'a' => '1'}}
+    end
+
+    it "allow if non jsonable objects are hidden in an array" do
+      class Bonkers
+        def to_json
+          no.can.do!
+        end
+      end
+      crazy = Bonkers.new
+      input = {'crazy' => [crazy]}
+      ErrorappNotifier::Sanitizer.sanitize_hash(input).should == {'crazy' => [crazy.to_s]}
+    end
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,12 @@
+class TestException < StandardError
+  attr_accessor :message, :backtrace
+
+  def initialize(opts={})
+    @message = opts[:message] || deafult_message
+    @backtrace = opts[:backtrace]
+  end
+
+  def deafult_message
+    "Something is not good"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'errorapp_notifier'
+require 'action_controller'
+require 'json'
+require 'webmock/rspec'
+require 'helper'
+
+ENV['RAILS_ENV'] = 'test'
+
+WebMock.disable_net_connect!(:allow_localhost => true)
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end