crashlog 0.0.1 → 0.0.2

data/spec/crash_log/initializer_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+# require 'crash_log/rails'
+
+describe "Initializer" do
+
+  let(:logger) { stub("Logger") }
+  let(:other_logger) { stub("OtherLogger") }
+
+  # before(:all) do
+  #   load_dummy_app
+  # end
+
+  describe 'auto configure logger' do
+    before do
+      load_dummy_app
+      # unless defined?(Rails)
+      #   module Rails
+      #   end
+      # end
+      Rails.stub(:logger).and_return(logger)
+      logger.stub(:error)
+      other_logger.stub(:error)
+    end
+
+
+    it 'detects presence of Rails logger' do
+      pending
+      # CrashLog::Rails.__send__(:initialize)
+      CrashLog.logger.should be(logger)
+    end
+
+    it "allows overriding of the logger if already assigned" do
+      pending
+      # unless defined?(::Rails)
+      #   module Rails
+      #   end
+      # end
+
+      Rails.stub(:logger).and_return(logger)
+
+      CrashLog.logger.should_not == logger
+      # CrashLog::Rails.initialize
+      CrashLog.logger.should == logger
+
+      CrashLog.configure do |config|
+        config.logger = other_logger
+      end
+
+      CrashLog.logger.should == other_logger
+    end
+  end
+
+end

data/spec/crash_log/payload_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+require 'json_spec'
+
+describe CrashLog::Payload do
+  include JsonSpec
+
+  let(:configuration) do
+    stub('configuration').tap do |config|
+      config.stub(:[])
+    end
+  end
+
+  subject { CrashLog::Payload.build(raised_error, configuration) }
+
+  let(:raised_error) do
+    begin
+      raise RuntimeError, "This broke"
+    rescue RuntimeError => e
+      e
+    end
+  end
+
+  describe '#add_context' do
+    it 'user_data should be empty' do
+      subject.context.should be_empty
+    end
+
+    it 'merges in new user data' do
+      data = {:email => "user@example.com"}
+      subject.add_context(data)
+      subject.context.should == data
+    end
+  end
+
+  describe '#add_session_data' do
+    it 'is empty by default' do
+      subject.environment[:session].should be_nil
+    end
+
+    it 'allows merging in data' do
+      data = {:path => '/problematic/path'}
+      subject.add_session_data(data)
+      subject.environment[:session].should == data
+    end
+
+    it 'allows adding more data' do
+      data_1 = {:path => '/problematic/path'}
+      data_2 = {:count => 42}
+      subject.add_session_data(data_1)
+      subject.add_session_data(data_2)
+
+      subject.environment[:session][:path].should == data_1[:path]
+      subject.environment[:session][:count].should == data_2[:count]
+    end
+  end
+
+  describe 'private.unwrap_exception' do
+    it 'unwraps exception objects' do
+      subject.__send__(:unwrap_exception, raised_error).should == raised_error
+    end
+  end
+
+  describe '#body' do
+
+    describe 'notifier' do
+      it 'has name' do
+        subject.body.to_json.should have_json_path('notifier/name')
+      end
+
+      it 'has version' do
+        subject.body.to_json.should have_json_path('notifier/version')
+      end
+    end
+
+    describe 'exception' do
+
+      it 'has class_name' do
+        subject.body.to_json.should have_json_path('event/type')
+      end
+
+      it 'has message' do
+        subject.body.to_json.should have_json_path('event/message')
+      end
+
+      describe 'backtrace' do
+        it 'has line number' do
+          subject.body.to_json.should have_json_path('backtrace/0/number')
+        end
+
+        it 'has integer as line number' do
+          subject.body.to_json.should have_json_type(Integer).at_path('backtrace/0/number')
+        end
+
+        it 'has filename' do
+          subject.body.to_json.should have_json_path('backtrace/0/file')
+        end
+
+        it 'has method' do
+          subject.body.to_json.should have_json_path('backtrace/0/method')
+        end
+      end
+
+      it 'has backtrace' do
+        subject.body.to_json.should have_json_path('backtrace/0')
+      end
+
+      it 'has timestamp' do
+        subject.body.to_json.should have_json_path('event/timestamp')
+      end
+    end
+
+    describe 'session' do
+
+    end
+
+    describe 'user_data' do
+      it 'has first key provided by user' do
+        pending
+        # subject.add_user_data({:email => "user@example.com"})
+        # subject.body.to_json.should have_json_path('user_data/email')
+      end
+    end
+  end
+end

data/spec/crash_log/reporter_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+describe CrashLog::Reporter do
+  let(:uuid) { UUID.generate }
+
+  let(:config) {
+    CrashLog::Configuration.new.tap do |config|
+      config.project_id = 'PROJECT_ID'
+      config.api_key = 'API_KEY'
+      # config.adapter = test_adapter
+      config.scheme = 'http'
+    end
+  }
+
+  # let(:config) { stub("Configuration", {
+  #   :host => "io.crashlog.io",
+  #   :scheme => "https",
+  #   :port => 443,
+  #   :endpoint => '/notify',
+  #   :announce => true,
+  #   :announce_endpoint => '/announce',
+  #   :dry_run => false,
+  #   :api_key => 'API_TOKEN',
+  #   :project_id => "PROJECT_ID",
+  #   :http_read_timeout => 1,
+  #   :http_open_timeout => 1
+  #   }).tap do |config|
+  #     config.stub(:adapter).and_return(:test, &test_adapter)
+  #   end
+  # }
+
+  let(:test_adapter) {
+    lambda { |stub|
+      stub.post('/events') do |env|
+        [201, {}, env[:request_headers]]
+      end
+    }
+  }
+
+  subject { CrashLog::Reporter.new(config) }
+
+  let(:positive_response) do
+    {:result_url => "https://crashlog.io/collect/#{uuid}"}
+  end
+
+  let(:announce_response) do
+    {:application => "CrashLog Test"}
+  end
+
+  let(:positive_response_json) { positive_response.to_json }
+  let(:announce_json) { announce_response.to_json }
+
+  let(:payload) {
+    {}
+  }
+
+  before do
+    CrashLog.stub(:report_for_duty!)
+  end
+
+  it 'should not be doing a dry run' do
+    subject.should_not be_dry_run
+  end
+
+  describe '#notify' do
+    before do
+      test_connection = Faraday.new(:url => subject.url) do |builder|
+        builder.adapter :test, stubs
+        builder.request :hmac_authentication, 'PROJECT_ID', 'SECRET', {:service_id => 'CrashLog'}
+        builder.request :url_encoded
+      end
+
+      subject.stub(:connection).and_return(test_connection)
+    end
+
+    let!(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.post('/events') { [200, {}, positive_response_json] }
+      end
+    end
+
+    after do
+      #stubs.verify_stubbed_calls
+    end
+
+    it 'makes a post request' do
+      subject.send(:connection).should_receive(:post).once
+      subject.notify(payload)
+    end
+
+    it 'authenticates request with HMAC' do
+      subject.notify(payload).should be_true
+      subject.response.env[:request_headers]['Authorization'].should ==
+        CrashLog::AuthHMAC.new({}, {:service_id => 'CrashLog'}).authorization(subject.response.env, 'PROJECT_ID', 'SECRET')
+      stubs.verify_stubbed_calls
+    end
+
+    it 'sends a serialized payload to crashlog.io' do
+      subject.notify(payload).should be_true
+
+      stubs.verify_stubbed_calls
+    end
+
+    it 'captures result body' do
+      subject.notify(payload).should be_true
+      subject.result.should == positive_response
+    end
+  end
+
+  describe '#announce' do
+    let!(:stubs) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.post('/announce') { [201, {}, announce_json] }
+      end
+    end
+
+    before do
+      test_connection = Faraday.new(:url => subject.url) do |builder|
+        builder.adapter :test, stubs
+      end
+
+      subject.stub(:connection).and_return(test_connection)
+    end
+
+    it 'sends an identification payload to CrashLog'
+
+    it 'responds with an application name' do
+      subject.announce.should === 'CrashLog Test'
+      stubs.verify_stubbed_calls
+    end
+  end
+
+  describe 'url' do
+    it 'constructs url from configuration' do
+      subject.url.to_s.should == 'http://stdin.crashlog.io'
+    end
+
+    it 'sends HMACAuth header'
+
+    #   # config.stub(:adapter).and_return(:test, &test_adapter)
+
+    #   # .and_return(:test).and_yield do |stub|
+    #   #   stub.post('/notify') do |env|
+    #   #     [200, {}, env[:request_headers]]
+    #   #   end
+    #   # end
+
+    #   # test_connection = Faraday.new(:url => subject.url) do |faraday|
+    #   #   faraday.adapter :test do |stub|
+    #   #     stub.post('/notify') do |env|
+    #   #       [200, {}, env[:request_headers]]
+    #   #     end
+    #   #   end
+    #   # end
+
+    #   #   #faraday.request   :url_encoded
+    #   #   faraday.request    :token_auth, "config.api_key"
+    #   #   #faraday.response  :logger
+    #   #   # faraday.token_auth config.api_key
+    #   #   faraday.options[:timeout] = 1
+    #   #   faraday.options[:open_timeout] = 1
+    #   #   faraday.ssl[:verify] = false
+    #   # end
+
+    #   # subject.stub(:connection).and_return(test_connection)
+    #   # subject.connection.adapter(:test) do |stub|
+    #   #   stub.post('/notify') do |env|
+    #   #     [200, {}, env[:request_headers]]
+    #   #   end
+    #   # end
+
+    #   subject.notify(payload).should be_true
+
+    #   subject.response.should == 'Token token=""'
+
+    #   stubs.verify_stubbed_calls
+    # end
+  end
+end

data/spec/crash_log_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe CrashLog do
+  def set_public_env
+    CrashLog.configure { |config| config.stage = 'production' }
+  end
+
+  def set_development_env
+    CrashLog.configure { |config| config.stage = 'development' }
+  end
+
+  let(:raised_error) do
+    begin
+      raise RuntimeError, "This broke"
+    rescue RuntimeError => e
+      e
+    end
+  end
+
+  after do
+    CrashLog.instance_variable_set("@configuration", nil)
+  end
+
+  let(:user) do
+    stub('User', :email => 'user@example.com')
+  end
+
+  describe '.notify' do
+    it 'does not send if not live' do
+      CrashLog::Reporter.any_instance.should_receive(:notify).never
+
+      CrashLog.stub(:live?).and_return(false)
+      CrashLog.notify(raised_error)
+    end
+
+    it 'handles being passed an exception object' do
+      CrashLog::Reporter.any_instance.should_receive(:notify).once
+
+      CrashLog.stub(:live?).and_return(true)
+      CrashLog.notify(raised_error)
+    end
+
+    it 'handles being passed an exception object and context' do
+      payload = {}
+
+      CrashLog::Reporter.any_instance.stub(:notify)
+        #should_receive(:notify).with(payload).once
+      CrashLog.stub(:live?).and_return(true)
+
+      context = {:current_user => user}
+      CrashLog.notify(raised_error, context)
+    end
+
+    it 'handles being passed a hash'
+    it 'handles being passed a string'
+  end
+
+  describe '.logger' do
+    it 'detects Rails.logger'
+    it 'defaults to STDOUT'
+  end
+
+  describe '.configuration' do
+    after do
+      CrashLog.instance_variable_set("@configuration", nil)
+    end
+
+    it 'handles being configured with a block' do
+      logger = stub("Logger")
+      logger.stub(:error)
+
+      CrashLog.configuration.logger.should be_nil
+      CrashLog.configure do |config|
+        config.logger = logger
+      end
+      CrashLog.configuration.logger.should == logger
+    end
+
+    it 'handles directly configuring attributes' do
+      logger = stub("Logger")
+      CrashLog.configuration.logger.should be_nil
+      CrashLog.configuration.logger = logger
+      CrashLog.configuration.logger.should == logger
+    end
+
+    it 'accepts api_key' do
+      key = stub("THIS IS AN API KEY")
+      CrashLog.configuration.api_key.should be_nil
+      CrashLog.configuration.api_key = key
+      CrashLog.configuration.api_key.should == key
+    end
+  end
+
+  describe '.ready' do
+    it 'logs an ready message' do
+      CrashLog::Reporter.any_instance.stub(:announce).and_return("Test Application")
+      logger = stub('Logger')
+      logger.should_receive(:info).
+        with("** [CrashLog] Initialized and ready to handle exceptions for Test Application")
+
+      CrashLog.stub(:logger).and_return(logger)
+      CrashLog.report_for_duty!
+    end
+  end
+
+  describe '.live?' do
+    it 'is live if current stage is included in release stages' do
+      CrashLog.configure do |c|
+        c.release_stages = ['test']
+        c.stage = 'test'
+      end
+
+      CrashLog.should be_live
+    end
+
+    it 'is not live if current stage is not included in release stages' do
+      CrashLog.configure do |c|
+        c.release_stages = ['production']
+        c.stage = 'test'
+      end
+
+      CrashLog.should_not be_live
+    end
+
+    it 'handles irregular stage names' do
+      CrashLog.configure do |c|
+        c.release_stages = ['test']
+        c.stage = 'Test'
+      end
+
+      CrashLog.configuration.stage.should === 'test'
+      CrashLog.should be_live
+    end
+  end
+
+  describe '#ignored?' do
+    it 'returns true if current exception is on ignored list' do
+      CrashLog.ignored?(RuntimeError.new).should be_false
+    end
+
+    it 'ignores ActiveRecord::RecordNotFound' do
+      # load_dummy_app
+      unless defined?(ActiveRecord)
+        module ActiveRecord
+          class RecordNotFound < RuntimeError
+          end
+        end
+      end
+
+      CrashLog.ignored?(ActiveRecord::RecordNotFound).should be_true
+    end
+  end
+end